linux使用线程实现生产者消费者问题,Linux平台下线程同步，实现“生产者消费者问题”...

(1)线程同步，实现“生产者消费者问题”

要求：缓冲区大小为20，生产者每次放一个产品，消费者每次取走一个产品；生产者和消费者至少2个。

(2)代码如下：

#include

#include

#include

#include

void *producter_f (void *arg);/*生产者*/

void *consumer_f (void *arg);/*消费者*/

int buffer_has_item=0;/*缓冲区计数值*/

pthread_mutex_t mutex;/*互斥区*/

//pthread_cond_t mqlock= PTHREAD_COND_INITIALIZER;

int running =1 ;/*线程运行控制*/

int main (void)

{

pthread_t consumer_t;/*消费者线程参数*/

pthread_t producter_t;/*生产者线程参数*/

pthread_mutex_init (&mutex,NULL);/*初始化互斥*/

pthread_create(&producter_t, NULL,(void*)producter_f, NULL );/*建立生产者线程*/

pthread_create (&consumer_t, NULL, (void *)consumer_f, NULL);/*建立消费者线程*/

//usleep(1);/*等待，线程创建完毕*/

//running =0;/*设置线程退出值*/

pthread_join(consumer_t,NULL);/*等待消费者线程退出*/

pthread_join(producter_t,NULL);/*等待生产者线程退出*/

pthread_mutex_destroy(&mutex);/*销毁互斥*/

return 0;

}

void *producter_f (void *arg)/*生产者线程程序*/

{

while(running)/*没有设置退出值*/

{

pthread_mutex_lock (&mutex);/*进入互斥区*/

if(buffer_has_item > 20) /*缓冲区满则不生产*/

{

pthread_mutex_unlock(&mutex);

usleep(1);

}

buffer_has_item++;/*增加计数值*/

printf("生产，总数量:%d\n",buffer_has_item); /*打印信息*/

pthread_mutex_unlock(&mutex);/*离开互斥区*/

}

}

void *consumer_f(void *arg)/*消费者线程程序*/

{

while(running)/*没有设置退出值*/

{

pthread_mutex_lock(&mutex);/*进入互斥区*/

buffer_has_item--;/*减小计数值*/

if(buffer_has_item < 0) /*缓冲区空则不消费*/

{

pthread_mutex_unlock(&mutex);

usleep(1);

}

printf("消费，总数量:%d\n",buffer_has_item);/*打印信息*/

pthread_mutex_unlock(&mutex);/*离开互斥区*/

}

}

(2)第二种，加入同步机制

#include

#include

#include

#include

#include

#define N 2 // 消费者或者生产者的数目

#define M 20 // 缓冲数目

int in = 0; // 生产者放置产品的位置

int out = 0; // 消费者取产品的位置

int buff[M] = { 0 }; // 缓冲初始化为0, 开始时没有产品

sem_t empty_sem; // 同步信号量, 当满了时阻止生产者放产品

sem_t full_sem; // 同步信号量, 当没产品时阻止消费者消费

pthread_mutex_t mutex; // 互斥信号量, 一次只有一个线程访问缓冲

int product_id = 0; //生产者id

int prochase_id = 0; //消费者id

/* 打印缓冲情况 */

void print()

{

int i;

for (i = 0; i < M; i++)

{

printf("%d ", buff[i]);

}

printf("\n");

}

/* 生产者方法 */

void *product()

{

int id = ++product_id; //当生产者进入的时候 执行计数加1

while (1)

{

// 用sleep的数量可以调节生产和消费的速度,便于观察

sleep(1);

sem_wait(&empty_sem);

pthread_mutex_lock(&mutex);

in = in % M;

printf("product%d in %d. like: \t", id, in);

buff[in] = 1;

print();

++in;

pthread_mutex_unlock(&mutex);

sem_post(&full_sem);

}

}

/* 消费者方法 */

void *prochase()

{

int id = ++prochase_id;

while (1)

{

// 用sleep的数量可以调节生产和消费的速度,便于观察

sleep(1);

sem_wait(&full_sem);

pthread_mutex_lock(&mutex);

out = out % M;

printf("prochase%d in %d. like: \t", id, out);

buff[out] = 0;

print();

++out;

pthread_mutex_unlock(&mutex);

sem_post(&empty_sem);

}

}

int main()

{

pthread_t id1[N];

pthread_t id2[N];

int i;

int ret[N];

// 初始化同步信号量

int ini1 = sem_init(&empty_sem, 0, M);

int ini2 = sem_init(&full_sem, 0, 0);

if (ini1 && ini2 != 0)

{

printf("sem init failed \n");

exit(1);

}

//初始化互斥信号量

int ini3 = pthread_mutex_init(&mutex, NULL);

if (ini3 != 0)

{

printf("mutex init failed \n");

exit(1);

}

// 创建N个生产者线程

for (i = 0; i < N; i++)

{

ret[i] = pthread_create(&id1[i], NULL, product, (void *) (&i));

if (ret[i] != 0)

{

printf("product%d creation failed \n", i);

exit(1);

}

}

//创建N个消费者线程

for (i = 0; i < N; i++)

{

ret[i] = pthread_create(&id2[i], NULL, prochase, NULL);

if (ret[i] != 0)

{

printf("prochase%d creation failed \n", i);

exit(1);

}

}

//销毁线程

for(i=0;i

{

pthread_join(id1[i],NULL);

pthread_join(id2[i],NULL);

}

exit(0);

}

运行结果：