单例模式

• 懒汉模式：在使用时候才创建出对象

 在多线程时，会出现安全问题 

 

 class Test{

 2   public：
 3       static Test* getInstance{
 4         if(m_test==NULL){
 5             m_test=new Test();    
 6         }          
 7          return m_test;
 8     }
 9 private:
10 //静态变量在使用之前必须初始化
11     static Test* m_test;
12     Test(){};
13     Test(const Test& t){};
14 }  
15 Test* Test::m_test=NULL;//初始化   

 

 

 

 

 /**加锁的第一种方式，效率低，多线程会线性进行**/

1 class Test{
 2   public：
 3       static Test* getInstance{
            mutex.lock();
 4         if(m_test==NULL){
 5             m_test=new Test();    
 6         } 
            mutex.unlock();         
 7          return m_test;
 8     }
 9 private:
10 //静态变量在使用之前必须初始化
11     static Test* m_test;
12     Test(){};
13     Test(const Test& t){};
14 }  
15 Test* Test::m_test=NULL;//初始化        

//加锁的第二种方式，多线程只有第一次会线性运行
class Test{
public：
    static Test* getInstance{
        if(m_test==NULL){
            mutex.lock();
             if(m_test==NULL){
                 m_test=new Test();    
             } 
            mutex.unlock();      
        }        
        return m_test;
     }
 private:
 //静态变量在使用之前必须初始化
     static Test* m_test;
    Test(){};
     Test(const Test& t){};
 }  
 Test* Test::m_test=NULL;//初始化 

//c++11才能使用
class Test{
public：
    static Test* getInstance();
 private:
    Test();
    Test(const Test& t);
 } 
//静态变量相当于全局变量，另一个线程在这里时就不会再创建这个静态变量了 
 Test::Test* getInstance(){
     static Test* test;
     return &test;
 } 

 

• 饿汉模式：在使用之前就被创建了

•  class Test{
  
   2   public：
   3       static Test* getInstance(){          
   7          return m_test;
   8     }
   9 private:
  10 //静态变量在使用之前必须初始化
  11     static Test* m_test;
  12     Test(){};
  13     Test(const Test& t){};
  14 }  
  15 Test* Test::m_test=new Test();//初始化