C++單例懶漢式和多執行緒問題(MUTEX 保護)

gaopengtttt發表於2017-04-10
C++單例執行緒Mutex
單例懶漢式和多執行緒問題


作為單例模式，是在整個程式執行期間只會建立一份記憶體空間，為了達到這個目標
1、需要將建構函式設定為私有成員
2、需要一個私有的靜態指標指向自身
3、需要一個公有的靜態函式將這個上面的靜態指標露出來

如下的程式碼就是一個懶漢式的單例

點選(此處)摺疊或開啟

  1. #include<iostream>
  2. using namespace std;

  4. class single_ins
  5. {
  6. private:
  7.     int a;
  8.     int b;
  9.     single_ins()
  10.     {
  11.         a= 0;
  12.         b= 0;
  13.     }
  14.     static single_ins* myc;
  15. public:
  16.     void setval(const int& a,const int& b)
  17.     {
  18.         this->a = a;
  19.         this->b = b;
  20.     }

  22.     void print()
  23.     {
  24.       cout<<"a:"<<a<<endl;
  25.       cout<<"b:"<<b<<endl;
  26.     }


  29.     static single_ins* setp()
  30.     {
  31.         //?
  32.         if(myc == NULL)
  33.         {
  34.             myc = new single_ins;
  35.         }
  36.         //?
  37.         return myc;
  38.     }

  40.     static void pfree()
  41.     {
  42.         if(myc != NULL)
  43.         {
  44.             delete myc;
  45.             myc = NULL;
  46.         }
  47.     }

  49. };

  51. //? init static value
  52. single_ins* single_ins::myc = NULL;
  53. //nit static value
  54. //single_ins* single_ins::myc = new single_ins;

  56. int main()
  57. {
  58.     single_ins* a = single_ins::setp();
  59.     single_ins* b = single_ins::setp();
  60.     a->setval(10,20);
  61.     b->print();

  63.     cout<<a<<" "<<b<<endl;
  64.     single_ins::pfree();

  66. }
但是上面的程式碼有明顯的問題，就是遇到多執行緒的情況下，因為多個執行緒如果同事建立記憶體，由於彼此之間
並不能及時檢查到記憶體已經分配，會分配多個記憶體，這個時候我們至少需要一個執行緒間同步手段來讓他們之間
序列的執行，這個時候就涉及到兩次檢查(double check)
如果沒有mutex保護就是下面這個程式：

點選(此處)摺疊或開啟

  1. #include <iostream>
  2. #include <unistd.h>
  3. using namespace std;


  6. //單列模式
  7. class single_ins
  8. {
  9.         private:
  10.                 int a;
  11.                 int b;
  12.                 single_ins()
  13.                 {
  14.                         cout<<"con begin\n";
  15.                         a= 0;
  16.                         b= 0;
  17.                         sleep(10); //故意拖長建構函式執行時間，造成懶漢式多執行緒問題
  18.                         cout<<"con end\n";
  19.                 }
  20.                 static single_ins* myc;//單例需要一個靜態指標
  21.                 static int cnt;//構造呼叫次數統計
  22.         public:
  23.                 void setval(const int& a,const int& b)
  24.                 {
  25.                         this->a = a;
  26.                         this->b = b;
  27.                 }

  29.                 void print()
  30.                 {
  31.                         cout<<"a:"<<a<<endl;
  32.                         cout<<"b:"<<b<<endl;
  33.                         cout<<cnt<<endl;
  34.                 }


  37.                 static single_ins* setp() //函式獲得指標值賦給靜態成員指標變數
  38.                 {
  39.                         //懶漢式
  40.                         if(myc == NULL)
  41.                         {
  42.                                 myc = new single_ins;
  43.                                 cnt++;
  44.                         }
  45.                         //懶漢式
  46.                         return myc;
  47.                 }
  48.                 static void pfree()
  49.                 {
  50.                         if(myc != NULL)
  51.                         {
  52.                                 delete myc;
  53.                                 myc = NULL;
  54.                         }
  55.                 }
  56. };

  58. //懶漢式 init static value
  59. single_ins* single_ins::myc = NULL;
  60. int single_ins::cnt = 0;
  61. //餓漢試 init static value
  62. //single_ins* single_ins::myc = new single_ins;
  63. /*
  64.    懶漢式的問題在於多執行緒呼叫的時候會出現問題，很可能同時建立出多個記憶體空間，
  65.    而不是單列了。
  66.    */
  67. void* main21(void* argc)
  68. {
  69.         single_ins* inp = (single_ins*)argc;

  71.         inp = single_ins::setp();
  72.         inp->setval(10,20);
  73.         inp->print();
  74.         cout<<inp<<"\n";
  75.         return NULL;
  76. }


  79. int main(void)
  80. {
  81.         pthread_t tid;
  82.         single_ins* a[3] = {NULL};
  83.         void* tret[3] = {NULL};
  84.         for(int i = 0 ; i<3; i++)
  85.         {
  86.                 pthread_create(&tid,NULL,main21,(void*)a[i]);
  87.                 //pthread_join(tid, &(tret[i]));
  88.         }
  89.         sleep(50);
  90.         single_ins::pfree();

  92. }
會跑出結果
con begin
con begin
con begin
con end
a:10
b:20
1
0x7fc3880008c0
con end
a:10
b:20
2
0x7fc3800008c0
con end
a:10
b:20
3
0x7fc3840008c0


可以看到
0x7fc3880008c0 0x7fc3800008c0 0x7fc3840008c0
明顯是3個不同的記憶體空間 這就不對了，而且可以看到建構函式
呼叫了3次
為此我們使用mutex來保護臨時

如下:
 static single_ins* setp() //函式獲得指標值賦給靜態成員指標變數
 39         {
 40             //懶漢式
 41             if(myc == NULL)
 42             {
 43                 pthread_mutex_lock(&counter_mutex); //mutex 保護臨界區
 44                 if(myc == NULL) //兩次檢查
 45                 {
 46                     myc = new single_ins;                                                                                                                           
 47                     cnt++;
 48                 }
 49                 pthread_mutex_unlock(&counter_mutex); //mutex結束
 50             }


這樣程式碼如下：

點選(此處)摺疊或開啟

  1. #include <iostream>
  2. #include <unistd.h>
  3. using namespace std;

  5. pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;

  7. //單列模式
  8. class single_ins
  9. {
  10.         private:
  11.                 int a;
  12.                 int b;
  13.                 single_ins()
  14.                 {
  15.                         cout<<"con begin\n";
  16.                         a= 0;
  17.                         b= 0;
  18.                         sleep(10); //故意拖長建構函式執行時間，造成懶漢式多執行緒問題
  19.                         cout<<"con end\n";
  20.                 }
  21.                 static single_ins* myc;//單例需要一個靜態指標
  22.                 static int cnt;//構造呼叫次數統計
  23.         public:
  24.                 void setval(const int& a,const int& b)
  25.                 {
  26.                         this->a = a;
  27.                         this->b = b;
  28.                 }

  30.                 void print()
  31.                 {
  32.                         cout<<"a:"<<a<<endl;
  33.                         cout<<"b:"<<b<<endl;
  34.                         cout<<cnt<<endl;
  35.                 }


  38.                 static single_ins* setp() //函式獲得指標值賦給靜態成員指標變數
  39.                 {
  40.                         //懶漢式
  41.                         if(myc == NULL)
  42.                         {
  43.                                 pthread_mutex_lock(&counter_mutex); //mutex 保護臨界區
  44.                                 if(myc == NULL) //兩次檢查
  45.                                 {
  46.                                         myc = new single_ins;
  47.                                         cnt++;
  48.                                 }
  49.                                 pthread_mutex_unlock(&counter_mutex); //mutex結束
  50.                         }
  51.                         //懶漢式
  52.                         return myc;
  53.                 }
  54.                 static void pfree()
  55.                 {
  56.                         if(myc != NULL)
  57.                         {
  58.                                 delete myc;
  59.                                 myc = NULL;
  60.                         }
  61.                 }
  62. };

  64. //懶漢式 init static value
  65. single_ins* single_ins::myc = NULL;
  66. int single_ins::cnt = 0;
  67. //餓漢試 init static value
  68. //single_ins* single_ins::myc = new single_ins;
  69. /*
  70.    懶漢式的問題在於多執行緒呼叫的時候會出現問題，很可能同時建立出多個記憶體空間，
  71.    而不是單列了。
  72.    */



  76. void* main21(void* argc)
  77. {
  78.         single_ins* inp = (single_ins*)argc;

  80.         inp = single_ins::setp();
  81.         inp->setval(10,20);
  82.         inp->print();
  83.         cout<<inp<<"\n";
  84.         return NULL;
  85. }


  88. int main(void)
  89. {
  90.         pthread_t tid;
  91.         single_ins* a[3] = {NULL};
  92.         void* tret[3] = {NULL};
  93.         for(int i = 0 ; i<3; i++)
  94.         {
  95.                 pthread_create(&tid,NULL,main21,(void*)a[i]);
  96.                 //pthread_join(tid, &(tret[i]));
  97.         }
  98.         sleep(50);
  99.         single_ins::pfree();

  101. }
跑出的結果如下：

con begin
con end
a:10a:10
b:20
1
0x7f21f40008c0


b:20
1
0x7f21f40008c0
a:10
b:20
1
0x7f21f40008c0


現在就是正常的了。所以懶漢試單例遇到多執行緒一定要注意，餓漢試沒有問題。
當然這是一個小列子而已，執行緒安全是一個很大的話題，特別需要注意。

作者微信：

               

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/7728585/viewspace-2136964/，如需轉載，請註明出處，否則將追究法律責任。

相關文章