线程同步学习1

看下简单的例子：

  1 #include <pthread.h>

  2 #include <stdlib.h>

  3 #include <stdio.h>

  4 #include <unistd.h>

  5 #include <string.h>

  6 

  7 pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER;

  8 struct foo

  9 {

 10     int f_count;

 11     pthread_mutex_t f_lock;

 12 };

 13 struct foo* AllocFoo()

 14 {

 15     foo* lpFoo = (foo*)malloc(sizeof(struct foo));

 16     if(NULL != lpFoo)

 17     {

 18         lpFoo->f_count = 1;

 19         if(0 != pthread_mutex_init(&lpFoo->f_lock,NULL))

 20         {

 21             printf("pthread_mutex_init error.\n");

 22             free(lpFoo);

 23             return NULL;

 24         }

 25     }

 26     printf("Alloc a Foo.\n");

 27     return lpFoo;

 28 }

 29 

 30 bool DestoryFoo(foo* apFoo)

 31 {

 32     pthread_mutex_lock(&apFoo->f_lock);

 33     if(--apFoo->f_count == 0)

 34     {

 35         printf("in DestoryFoo: f_coount:%d.\n",apFoo->f_count);

 36         pthread_mutex_unlock(&apFoo->f_lock);

 37         pthread_mutex_destroy(&apFoo->f_lock);

 38         free(apFoo);

 39         printf("Destroy foo.\n");

 40         return true;

 41     }

 42     else

 43     {

 44         printf("in DestoryFoo: f_coount:%d.\n",apFoo->f_count);

 45         pthread_mutex_unlock(&apFoo->f_lock);

 46         return false;

 47     }

 48 }

 49 

 50 void HoldFoo(foo* apFoo)

 51 {

 52     pthread_mutex_lock(&apFoo->f_lock);

 53     ++apFoo->f_count;

 54     printf("in  HoldFoo f_coount:%d.\n",apFoo->f_count);

 55     pthread_mutex_unlock(&apFoo->f_lock);

 56 }

 57 

 58 void PrintTids(const char* s);

 59 

 60 void* ThreadFun(void* Arg)

 61 {

 62     PrintTids("");

 63     foo* lpFoo = (foo*)Arg;

 64     for(int i=0;i<5;++i)

 65     {

 66         //pthread_mutex_lock(&glock);

 67         HoldFoo(lpFoo);

 68         //pthread_mutex_unlock(&glock);

 69     }

 70     return NULL;

 71 }

 72 void PrintTids(const char* s)

 73 {

 74     pid_t lPid = getpid();

 75     pthread_t lTid = pthread_self();

 76     printf("%s pid:%u,tid:(0x%x).\n",s,(unsigned int)lPid, (unsigned int)lTid);

 77 }

 78 int main()

 79 {

 80     foo* lpFoo = AllocFoo();

 81     pthread_t lTid1;

 82     int lErr = pthread_create(&lTid1,NULL,ThreadFun,lpFoo);

 83     if(0 != lErr)

 84     {

 85         exit(1);

 86     }

 87     printf("main thread");

 88 

 89     pthread_t lTid2;

 90     lErr = pthread_create(&lTid2,NULL,ThreadFun,lpFoo);

 91     if(0 != lErr)

 92     {

 93         exit(1);

 94     }

 95     //HoldFoo(lpFoo);

 96     void* lTret;

 97     lErr = pthread_join(lTid1,&lTret);

 98     if(0 != lErr)

 99     {

100         printf("can't join thread1.\n");

101     }

102     lErr = pthread_join(lTid2,&lTret);

103     if(0 != lErr)

104     {

105         printf("can't join thread1.\n");

106     }

107 

108     bool lIsDestory = false;

109     do

110     {

111         lIsDestory = DestoryFoo(lpFoo);

112     }while(!lIsDestory);

113 }

 输出：