生产者消费者问题
生产者消费者共享缓冲区，生产者向缓冲区中放数据，消费者从缓冲取中取数据，当缓冲区中被放满时，生产者进程就必须进入挂起状态，直到消费者从缓冲中取走数据时，生产者才能继续向缓冲区中存放数据，同样当缓冲取中没有数据时，消费者进程就必须进入挂起休眠状态，直到生产者向缓冲区中放入数据时，消费者才能被唤醒继续从缓冲区中取走数据。
单生产者，单消费者
因为有单生产者和单消费者，致使在一个缓冲区满时生产者需要等待消费，一个缓冲区空时消费者也要等待生产。
利用两个pthread库中的互斥锁
先定义初始化，利用静态赋值法，以及定义两个互斥锁；
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t thread[2];
pthread_mutex_t mut;
pthread_mutex_t mut2;
先定义全局变量，producer用的time1,consumer用的time2，以及大小为20的缓冲区，以及一个函数t；
#include<stdio.h>
#include<pthread.h>
int buffer[20],t = 0,time1 = 0,time2 = 0;
分为两个函数，一个是生产者的函数；
先判断是否已满，满则加锁；
void producer()
{
while(1)
{
if(time1 == 20)
return;
pthread_mutex_lock(&mut);
判断加锁是否成功，如阻塞则等待，不阻塞则继续；
if(t == 20)
{
printf("缓冲区阻塞，生产者等待。\n");
pthread_mutex_unlock(&mut2);
continue;
}
输出生产者置于多少，增加循环参数，并且解锁。
最后函数为：
void producer()
{
while(1)
{
if(time1 == 20)
return;
pthread_mutex_lock(&mut);
if(t == 20)
{
printf("缓冲区阻塞，生产者等待。\n");
pthread_mutex_unlock(&mut2);
continue;
}
printf("生产者位于%d\n", time1);
t++;
time1++;
pthread_mutex_unlock(&mut2);
}
}
再进行消费者函数；
void consumer()
{
while(1)
{
if(time2 == 20)
return;
pthread_mutex_lock(&mut2);
if(t == 0)
{
printf("缓冲区空了，消费者等待\n");
pthread_mutex_unlock(&mut);
continue;
}
printf("消费者得到%d\n", time2);
t--;
time2;
pthread_mutex_unlock(&mut);
}
}
最后加入主函数；
int main()
{
pthread_create(&thread[0], NULL, (void*)(&producer), NULL);
pthread_create(&thread[1], NULL, (void*)(&consumer), NULL);
sleep(1);
return 0;
}
多生产者，多消费者
先进行头文件和宏定义
//semaphores
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <unistd.h>
#define BUFFER_SIZE 5
定义semaphore记录有多少个线程正在使用
sem_t empty, full, mutex;
定义缓冲区
int buffer[BUFFER_SIZE];
int in, out;
定义存储数据的结构体
struct data {
int id;
int opTime;
int lastTime;
int productId;
};
定义有限输入
int insert_item(buffer_item item)
{
buffer[out] = item;
out = (out + 1) % BUFFER_SIZE;
return 0;
}
定义有限删除
int remove_item(buffer_item *item)
{
*item = buffer[in];
in = (in + 1) % BUFFER_SIZE;
return 0;
}
接下来是生产者部分的函数
先定义生产者id，始末次数，总id
void *producer(void* param) {
int productId = ((struct data*)param)->productId;
int lastTime = ((struct data*)param)->lastTime;
int opTime = ((struct data*)param)->opTime;
int id = ((struct data*)param)->id;
然后在是释放空间，并为信号量减1
free(param);
sleep(opTime);
sem_wait(&empty);
sem_wait(&mutex);
再做临界段的处理，并为信号量加1
insert_item(productId);
sleep(lastTime);
printf("Thread %d: Producer produce %d\n", id, productId);
sem_post(&mutex);
sem_post(&full);
pthread_exit(0);
}
然后是消费者的函数
void *consumer(void* param) {
int lastTime = (
(struct data*)param)->lastTime;
int opTime = ((struct data*)param)->opTime;
int id = ((struct data*)param)->id;
free(param);
sleep(opTime);
sem_wait(&full);
sem_wait(&mutex);
buffer_item item;
remove_item(&item);
sleep(lastTime);
printf("Thread %d: Consumer consume %d\n", id, item);
sem_post(&mutex);
sem_post(&empty);
pthread_exit(0);
}
最后进行主函数
定义线程标识符，线成属性
int main()
{
pthread_t tid;
pthread_attr_t attr;
再对线程和信号量初始化
pthread_attr_init(&attr);
sem_init(&mutex, 0, 1);
sem_init(&empty, 0, BUFFER_SIZE);
sem_init(&full, 0, 0);
in = out = 0;
再定义生产者和消费者的运行时间和id及创建线程，并运行函数
int id = 0;
while(scanf("%d", &id) != EOF)
{
char role;
id scanf("%c%d%d", &role, &opTime, &lastTime);
struct data* d = (struct data*)malloc(sizeof(struct data));
d->id = id; d->opTime = opTime;
d->lastTime = lastTime;
if(role == 'P')
{
scanf("%d", &productId);
d->productId = productId;
pthread_create(&tid, &attr, producer, d);
}
else if(role == 'C')
pthread_create(&tid, &attr, consumer, d); }
最后释放信号量
sem_destroy(&mutex);
sem_destroy(&empty);
sem_destroy(&full);
return 0;
}sem_destroy(&mutex);
sem_destroy(&empty);
sem_destroy(&full);
return 0;
}