linux下线程同步

这里我做的测试使用的模型是生产者消费者模型，分成两种情况

其一只有一个缓冲区，我们使用信号量即可，分成两个，empty  和full。当缓冲区有空时，则生产者生产，当缓冲区full时。消费者消费

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<string.h>
#include<semaphore.h>
//生产者消费者模式，只有一个缓冲区，一个消费者一个生产者
//使用信号量进行线程同步
void* consumer(void* arg);
void* producer(void* arg);
int gBuffer=0;
sem_t empty={0};
sem_t full={0};
int main()
{
  pthread_t c_th={0};
  pthread_t p_th={0};
  int c_res=0;
  int p_res=0;
  sem_init(&empty,0,1);
  sem_init(&full,0,0);
  c_res=pthread_create(&c_th,NULL,consumer,(void*)&gBuffer);
  if(0!=c_res)
  {
    printf("消费者线程创建失败\n");
    exit(0);
  }
  p_res=pthread_create(&p_th,NULL,producer,(void*)&gBuffer);
  if(0!=p_res)
  {
    printf("生产者线程创建失败\n");  
    exit(0);
  }
  void* c_rtl=NULL;
  c_res=pthread_join(c_th,&c_rtl);
  if(0!=c_res)
  {
    printf("消费者线程 pthread_join 失败\n");
    exit(0);
  }
  void* p_rtl=NULL;
  p_res=pthread_join(p_th,&p_rtl);
  if(0!=p_res)
  { 
    printf("生产者 pthread_join 失败\n");
    exit(0);
  }
  sem_destroy(&full);
  sem_destroy(&empty);
  return 0;
}
void * consumer(void* arg)
{
  int nCount=0;
  while(1)
  {
    sem_wait(&full);
    printf("consumer 成功\n");
    sem_post(&empty);
    nCount++;
    if(50==nCount)
      break;
  }
  pthread_exit(0);
}
void * producer(void* arg)
{
  int nCount=0;
  while(1)
  {
    sem_wait(&empty);
    printf("producer 成功\n");
    sem_post(&full);
    nCount++;
    if(50==nCount)
      break;
  }
  pthread_exit(0);
}

当存在多个缓冲区的时候，则除却信号量标记，缓冲区状态的时候，还要为每个缓冲区分配互斥变量，同一时刻，一个缓冲区只能被一个线程访问，无论是生产者还是消费者

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<string.h>
#include<semaphore.h>
//生产者消费者模式，多个缓冲区，多个生产者
//使用信号量进行线程同步
void* consumer(void* arg);
void* producer(void* arg);
int gBuffer[4]={0};
int buf_count=4;
//为每个缓冲区都准备一个互斥变量，同一时间只能有一个线程进行访问
pthread_mutex_t mutex[4]={0};
sem_t empty={0};
sem_t full={0};
int main()
{
  pthread_t c_th={0};
  pthread_t p_th={0};
  int c_res=0;
  int p_res=0;
  sem_init(&empty,0,4);
  sem_init(&full,0,0);
  int i=0;
  for(;i<buf_count;i++)
  {
    pthread_mutex_init(&mutex[i],NULL);
  }
  c_res=pthread_create(&c_th,NULL,consumer,(void*)&gBuffer);
  if(0!=c_res)
  {
    printf("消费者线程创建失败\n");
    exit(0);
  }
  p_res=pthread_create(&p_th,NULL,producer,(void*)&gBuffer);
  if(0!=p_res)
  {
    printf("生产者线程创建失败\n");  
    exit(0);
  }
  void* c_rtl=NULL;
  c_res=pthread_join(c_th,&c_rtl);
  if(0!=c_res)
  {
    printf("消费者线程 pthread_join 失败\n");
    exit(0);
  }
  void* p_rtl=NULL;
  p_res=pthread_join(p_th,&p_rtl);
  if(0!=p_res)
  { 
    printf("生产者 pthread_join 失败\n");
    exit(0);
  }
  sem_destroy(&full);
  sem_destroy(&empty);
  for(i=0;i<buf_count;i++)
  {
    pthread_mutex_destroy(&mutex[i]);
  }
  return 0;
}
void * consumer(void* arg)
{
  int nCount=0;
  int i=0;
  while(nCount<=20)
  {
    sem_wait(&full);
    for(i=0;i<buf_count;i++)     
    {
      if(1==gBuffer[i])
      {
        pthread_mutex_lock(&mutex[i]);
        gBuffer[i]=0;
        printf("缓冲区%d归0\n",i);    
        pthread_mutex_unlock(&mutex[i]);
        sem_post(&empty);
        nCount++;
      }
    }
  }
  pthread_exit(0);
}
void * producer(void* arg)
{
  int nCount=0;
  int i=0;
  while(nCount<=20)
  {
    sem_wait(&empty);
    for(i=0;i<buf_count;i++)
    {
      if(gBuffer[i]==0)
        {
          pthread_mutex_lock(&mutex[i]);
          gBuffer[i]=1;
          printf("缓冲区%d置位\n",i);
          pthread_mutex_unlock(&mutex[i]);
          sem_post(&full);
          nCount++;
        }
    }   
  }
  pthread_exit(0);
}

跟上一篇一样，说下 makefile的内容，多了一个  -lrt

test: thread.o
  gcc -o test thread.o  -lpthread  -lrt
thread.o:thread.c
  gcc -c thread.c
clean:
  rm test *.o