码迷,mamicode.com
首页 > 其他好文 > 详细

设计模式的简单理解——单例模式

时间:2019-03-31 13:47:40      阅读:169      评论:0      收藏:0      [点我收藏+]

标签:join   tor   优化   vector   约束   ack   name   实现   res   

简单理解

单例模式是指进程生命期内,某个类型只实例化一个对象。这是一种通过语言特性实现的编程约束。如果没有约束,那么多人协同编码时,就会出现非预期的情况。

下面以内存池做例子,假设其类型名为MemoryPool。内存池的本意是统一管理全局内存,优化内存分配,提升性能,记录内存分配信息方便追溯问题,需要全局只有一个实例对象。

第一阶段:没有任何约束

因为没有任何约束,大家会各自实例化MemoryPool对象来使用。最终一片混乱,根本达不到最初使用内存池的目的。

第二阶段:编程语言外的约束

MemoryPool处添加注释,告诉大家只能使用一个MemoryPool的全局变量。刚开始还挺好,但总会有一些人不知道为什么就自己实例化MemoryPool对象来使用。因为破窗效应,最终越来越乱,出现第一阶段的情况。

第三阶段:编程语言的约束

MemoryPool的构造函数、拷贝构造函数、赋值构造函数都设为私有,只允许使用者通过一个接口来获取MemoryPool对象。当有人想自己实例化MemoryPool对象来使用时,编译就会报错。接口内只返回固定的一个已实例化的对象,完美!

实现

单例一般有两种方式

  • 程序初始化阶段时构造单例对象:进入main()之前构造,没有多线程问题,但不论是否使用都占用了资源
  • 使用时才构造单例对象:使用时才占用资源,但需要注意多线程竞争问题

以下是C++实现的单例代码
Singletion.h

#ifndef __SINGLETON_H__
#define __SINGLETON_H__

#include <mutex>

/**
 * @brief 单例模板
 * @detail 使用单例模式的类型需要将该模板设为友元类
 */
template<typename T>
class Singleton
{
public:
    static T* instance()
    {
        std::call_once( m_once, [](){ m_instance = new T; } );
        return m_instance;
    }

    static void destroy()   
    {
        if( NULL != m_instance ){
            delete m_instance;
            m_instance = NULL;
        }
        return;
    }
private:
    static T* m_instance;
    static std::once_flag m_once;
};
template<typename T>
T* Singleton<T>::m_instance = NULL;

template<typename T>
std::once_flag Singleton<T>::m_once;

#endif

std::call_once()在Linux平台调用的是pthread_once()。flag有三个状态NEVER(0)、IN_PROGRESS(1)、DONE(2),其中使用了两个带LOCK前缀的指令:cmpxchg和incl。lock cmpxchg 将flag从0变为1,lock incl将flag从1变为2。lock锁定特定内存地址,避免其他CPU读取或者修改这个内存地址的值。

Adder.h

#ifndef __ADDER_H__
#define __ADDER_H__

#include "Singleton.h"
#include <atomic>

/**
 * @brief 累加器
 * @detail 使用单例模式,全局累加器
 */
class Adder
{
    friend class Singleton<Adder>;
public:
    Adder& operator<<(int32_t n)
    {
        m_num += n;
        return *this;
    }
    
    int32_t value()
    {
        return m_num;
    }
private:
    Adder()
    {
    }
    Adder(Adder&);
    Adder& operator=(Adder&);

private:
     std::atomic<int32_t> m_num;
};

#endif

main.cpp

#include "Adder.h"

#include <thread>
#include <vector>
#include <iostream>
void worker()
{
    int i = 1000000;
    while( i-- ){
        *(Singleton<Adder>::instance()) << 1;   
    }
    return;
}
int main()
{
    std::vector<std::thread> threads;
    for( int i = 0; i < 10; ++i ){
        std::thread t( worker );
        threads.push_back( std::move( t ) );
    }
    
    for( int i = 0; i < 10; ++i ){
        threads[i].join();
    }
    // 输出等于1000万
    std::cout << Singleton<Adder>::instance()->value() << std::endl;
    return 0;
}

设计模式的简单理解——单例模式

标签:join   tor   优化   vector   约束   ack   name   实现   res   

原文地址:https://www.cnblogs.com/yizui/p/10630820.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!