信号量

子线程被阻塞，主线程可以激活，这就是线程的同步问题。
信号量就可以实现线程同步

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <pthread.h>
  5. #include <semaphore.h>
  7. char buf[1024] = {0};
  8. sem_t sem;
  9. int flag = 0;
  11. void *func(void *arg)
  12. {
  13.     sem_wait(&sem);
  14.     while(!flag)
  15.     {
  17.         printf("count: %d\n", strlen(buf));
  18.         memset(buf, 0, sizeof(buf));
  19.         sem_wait(&sem);
  20.     }
  21.     pthread_exit(NULL);
  22. }
  24. int main(int argc, char **argv)
  25. {
  26.     int ret = -1;
  27.     pthread_t th = -1;
  30.     sem_init(&sem, 0, 0);
  32.     ret = pthread_create(&th, NULL, func, NULL);
  33.     if(ret != 0)
  34.     {
  35.         printf("pthread_create failed");
  36.         exit(-1);
  37.     }
  39.     printf("please input: \n");
  40.     while (scanf("%s", buf))
  41.     {
  42.         if(!strncmp(buf, "end", 3))
  43.         {
  44.             printf("process end\n");
  45.             flag = 1;
  46.             sem_post(&sem);
  47.             break;
  48.         }
  50.         sem_post(&sem);
  52.     }
  54.     printf("wait for recycle thread\n");
  55.     ret = pthread_join(th, NULL);
  56.     if(ret != 0)
  57.     {
  58.         printf("pthread_create failed");
  59.         exit(-1);
  60.     }
  61.     printf("finish recycle thread\n");
  62.     sem_destroy(&sem);
  64.     return 0;
  65. }

互斥锁

互斥锁又叫做互斥量mutex
互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。
注意: 互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。
相关函数：
pthread_mutex_init 功能：初始化一个互斥锁
pthread_mutex_destroy 功能：销毁一个互斥锁
pthread_mutex_lock 功能：加锁
pthread_mutex_unlock 功能：尝试加锁

互斥锁和信号量的关系：可以认为互斥锁是一种特殊的信号量

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <pthread.h>
  6. char buf[1024] = {0};
  7. pthread_mutex_t mutex;
  8. int flag = 0;
  10. void *func(void *arg)
  11. {
  12.     sleep(1);
  13.     while(!flag)
  14.     {
  15.         pthread_mutex_lock(&mutex);
  16.         printf("count: %d\n", strlen(buf));
  17.         memset(buf, 0, sizeof(buf));
  18.         pthread_mutex_unlock(&mutex);
  19.         sleep(1);
  20.     }
  21.     pthread_exit(NULL);
  22. }
  24. int main(int argc, char **argv)
  25. {
  26.     int ret = -1;
  27.     pthread_t th = -1;
  29.     pthread_mutex_init (&mutex, NULL);
  32.     ret = pthread_create(&th, NULL, func, NULL);
  33.     if(ret != 0)
  34.     {
  35.         printf("pthread_create failed");
  36.         exit(-1);
  37.     }
  39.     printf("please input: \n");
  40.     while (1)
  41.     {
  42.         pthread_mutex_lock(&mutex);
  43.         scanf("%s", buf);
  44.         pthread_mutex_unlock(&mutex);
  45.         if(!strncmp(buf, "end", 3))
  46.         {
  47.             printf("process end\n");
  48.             flag = 1;
  49.             break;
  50.         }
  51.         sleep(1);
  53.     }
  55.     printf("wait for recycle thread\n");
  56.     ret = pthread_join(th, NULL);
  57.     if(ret != 0)
  58.     {
  59.         printf("pthread_join failed");
  60.         exit(-1);
  61.     }
  62.     printf("finish recycle thread\n");
  64.     pthread_mutex_destroy(&mutex);
  66.     return 0;
  67. }

条件变量

相关函数：
pthread_cond_init
pthread_cond_destory
pthread_cond_wait
pthread_cond_signal/pthread_cond_broadcast

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <pthread.h>
  6. char buf[1024] = {0};
  7. pthread_mutex_t mutex;
  8. pthread_cond_t cond;
  9. int flag = 0;
  11. void *func(void *arg)
  12. {
  13.     while(!flag)
  14.     {
  15.         pthread_mutex_lock(&mutex);
  16.         pthread_cond_wait(&cond, &mutex);
  17.         printf("count: %d\n", strlen(buf));
  18.         memset(buf, 0, sizeof(buf));
  19.         pthread_mutex_unlock(&mutex);
  20.         //sleep(1);
  21.     }
  22.     pthread_exit(NULL);
  23. }
  25. int main(int argc, char **argv)
  26. {
  27.     int ret = -1;
  28.     pthread_t th = -1;
  30.     pthread_mutex_init(&mutex, NULL);
  31.     pthread_cond_init(&cond, NULL);
  34.     ret = pthread_create(&th, NULL, func, NULL);
  35.     if(ret != 0)
  36.     {
  37.         printf("pthread_create failed");
  38.         exit(-1);
  39.     }
  41.     printf("please input: \n");
  42.     while (1)
  43.     {
  44.         //pthread_mutex_lock(&mutex);
  47.         scanf("%s", buf);
  48.         pthread_cond_signal(&cond);
  49.         pthread_mutex_unlock(&mutex);
  50.         if(!strncmp(buf, "end", 3))
  51.         {
  52.             printf("process end\n");
  53.             flag = 1;
  54.             break;
  55.         }
  56.         //sleep(1);
  58.     }
  60.     printf("wait for recycle thread\n");
  61.     ret = pthread_join(th, NULL);
  62.     if(ret != 0)
  63.     {
  64.         printf("pthread_create failed");
  65.         exit(-1);
  66.     }
  67.     printf("finish recycle thread\n");
  69.     pthread_mutex_destroy(&mutex);
  70.     pthread_cond_destroy(&cond);
  72.     return 0;
  73. }