生产者---消费者 、 读 者-----写者 模型相关代码实现

producter_consumer_model.c 

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>


#define CONSUMERS_COUNT 8
#define PRODUCERS_COUNT 8

pthread_cond_t cond;
pthread_mutex_t mutex;
pthread_t threads[CONSUMERS_COUNT+PRODUCERS_COUNT];

typedef struct msg
{
    int num;
    struct msg *next;

}msg;

struct msg * head = NULL;

msg* CreatNode(int value)
{
  msg* tmp=(msg*)malloc(sizeof(msg));
  tmp->num=value;
  tmp->next=NULL;
  return tmp;
}

void DestroyNode(struct msg* to_free)
{
    free(to_free);
}




void* consumer(void* p)
{
    int num= *(int*)p;
    free(p);
    struct msg *mp=NULL;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        while(head->next==NULL)
        {
            printf("%d begin wait a condition.\n",num);
            pthread_cond_wait(&cond,&mutex);

        }
        printf("%d end wait a conditon.\n", num);
        printf("%d beign consume product.\n", num);
       
        mp=head->next;
        head->next=mp->next;

        pthread_mutex_unlock(&mutex);

        printf("Consume %d\n",mp->num);

        DestroyNode(mp);    
        
        printf("%d end his conmsume.\n", num);
        
        sleep(10);



    }

} 
void *producer(void* p)
{
     struct msg * mp;
     int num=*(int*)p;
     free(p);
   
     while(1)
     {
         printf("%d begin produce product...\n", num);
         int value=rand()%999+1;
         mp=CreatNode(value);

         printf("My product is %d",mp->num);
         pthread_mutex_lock(&mutex);
         
         mp->next=head->next;
         head->next=mp;
        
         printf("%d finish produce.\n", num);
         pthread_cond_signal(&cond);
         pthread_mutex_unlock(&mutex);
         sleep(10);


     }
  
}

int main()
{
    head=CreatNode(-1);
    pthread_cond_init(&cond,NULL);
    pthread_mutex_init(&mutex,NULL);

    int i;
    for(i=0;i<PRODUCERS_COUNT;i++)
    {
      int *p=(int*)malloc(sizeof(int));
      *p=i+1;
      pthread_create(&threads[i],NULL, producer, (void*)p);

    }

    for(i=0;i<CONSUMERS_COUNT;i++)
    {
        int *p=(int*)malloc(sizeof(int));
        *p=i+1;
        pthread_create(&threads[PRODUCERS_COUNT+i],NULL, consumer,(void*)p );
    }

    for(i=0;i<CONSUMERS_COUNT+PRODUCERS_COUNT;i++)
    {
        pthread_join(threads[i],NULL);
    }

    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);

}

semaphore.c

#include<unistd.h>
#include<sys/types.h>
#include<pthread.h>
#include<semaphore.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>


#define ERR_EXIT(m)\
    do \
{\
  perror(m);\
    exit(EXIT_FAILURE);\
}while(0)


#define CONSUMER_COUNT 1
#define PRODUCER_COUNT 9

#define BUFFSIZE 10
int g_buffer[BUFFSIZE];

unsigned short in=0;

unsigned short out=0;
unsigned short produce_id=0;
unsigned short consume_id=0;


sem_t g_sem_full;
sem_t g_sem_empty;

pthread_mutex_t g_mutex;

pthread_t g_thread[CONSUMER_COUNT+PRODUCER_COUNT];

 void *consume(void* arg)
{
   int i;
   int num=*(int*)arg;
   free(arg);
   while(1)
   {
       printf("%d wait buffer not empty.\n", num);
       sem_wait(&g_sem_empty);
       pthread_mutex_lock(&g_mutex);

       for(i=0;i<BUFFSIZE;i++)
       {
           printf("%02d ", i);
           if(g_buffer[i]==-1)
           {
              printf("%s","null");
           }
           else
           {
               printf("%d", g_buffer[i]);
           }

           if(i==out)
           {
               printf("\t<--consume");
           }
           printf("\n");

       }

    consume_id =g_buffer[out];
    printf("%d begin consume product %d\n", num , consume_id);
    g_buffer[out] = -1;
    out = (out+1)% BUFFSIZE;
    printf("%d end onsume product %d\n",num , consume_id );
    pthread_mutex_unlock(&g_mutex);
    sem_post(&g_sem_full);
    sleep(2);
   }

   return NULL;

}

void* produce(void* arg)
{
  int i;
  int num= *(int*)arg;
  free(arg);
  while(1)
  {
      printf("%d wait buffer not full\n", num);
      sem_wait(&g_sem_full);
      pthread_mutex_lock(&g_mutex);
      for(i=0; i< BUFFSIZE;i++)
      {
          printf("%02d " ,i);
          if(g_buffer[i]==-1)
          {
              printf("%s", "null");
          }
          else
          {
              printf("%d", g_buffer[i]);
          }

          if(i==in)
          {
              printf("\t<--produce");
          }
          printf("\n");
      }

      printf("%d begin produce product %d\n", num , produce_id);
      g_buffer[in]=produce_id;
      in = (in+1)% BUFFSIZE;
      printf("%d end produce product %d\n", num , produce_id++);
      pthread_mutex_unlock(&g_mutex);
      sem_post(&g_sem_empty);
      sleep(5);
  }
  return NULL;
}

int main()
{
    int i;
    for(i=0;i<BUFFSIZE;i++)
    {
        g_buffer[i]=-1;
    }

    sem_init(&g_sem_full, 0 ,BUFFSIZE);
    sem_init(&g_sem_empty, 0, 0);

    pthread_mutex_init(&g_mutex,NULL);
    
    for(i=0;i<CONSUMER_COUNT;i++)
    {
        int *p=(int*)malloc(sizeof(int));
        *p =i;

        pthread_create(&g_thread[i],NULL, consume, (void*)p);
    }

    for(i=0;i<PRODUCER_COUNT;i++)
    {
        int *p=(int*)malloc(sizeof(int));
        *p=i;
        pthread_create(&g_thread[i+CONSUMER_COUNT],NULL, produce, (void*)p);
    }
    
    for(i=0;i<CONSUMER_COUNT+PRODUCER_COUNT;i++)
    {
        pthread_join(g_thread[i],NULL);
    }
    
    sem_destroy(&g_sem_empty);

    sem_destroy(&g_sem_full);
    pthread_mutex_destroy(&g_mutex);
    
    return 0;
    
}

 rwlock.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>

#define READER 5
#define WRITER 3
int counter;

pthread_rwlock_t rwlock;

void *route_write(void* arg)
{
    int t;
    int i =*(int*)arg;
    free(arg);
    
    while(1)
    {
        t=counter;
        usleep(1000000);
        
        pthread_rwlock_wrlock(&rwlock);
        printf("rwite:%d  :%#x : counter=%d  ++counter=%d\n",i ,(unsigned int)pthread_self(), t, ++counter );
        pthread_rwlock_unlock(&rwlock);
        usleep(5000000);

    }


}

void *route_read(void* arg)
{
   int i = *(int*)arg;
   free(arg);

   while(1)
   {
       pthread_rwlock_rdlock(&rwlock);
       printf("read :%d :%#x :counter=%d \n",i, (unsigned int)pthread_self(), counter);
       pthread_rwlock_unlock(&rwlock);
       usleep(900000);
   }
}

int main()
{
    int i;
    pthread_t tid[READER+WRITER];
   
    pthread_rwlock_init(&rwlock, NULL);

    for(i=0;i<READER;i++)
    {
       int *p=(int*)malloc(sizeof(int));
       *p = i;
       pthread_create(&tid[i], NULL, route_read, (void*)p);
    }

    for(i=0;i<WRITER;i++)
    {
        int * p= (int*)malloc(sizeof(int));
        *p =i;
        pthread_create(&tid[i+READER], NULL, route_write, (void*)p);
    }

    for(i=0;i<READER+WRITER;i++)
    {
        pthread_join(tid[i],NULL);
    }

    pthread_rwlock_destroy(&rwlock);

}