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);
}