linux c 多线程 生产者--消费者

linux 线程同步机制和java的是极其类似的。如果不太明白java多线程编程，可以参考我原先写的java多线程编程。下面我们将展现linux下如何实现生产者和消费者模型。

 

直接上代码吧：

 #ifndef _LIST_H_

#define _LIST_H_
#include <string.h>
#include <stdio.h>

struct List
{
	char buffer[10];
	char * cursor;
	char * begin;
	char * end;
	
};
// you must add struct, otherwise it will prompt "expected ‘)’ before ‘*’ token"
void init(struct List * p_list);
int get_buffer_length (struct List * p_list);
void put_into_buffer(struct List* p_list,char *pc_char);
char get_from_buffer(struct List* p_list);


#endif

 这个头文件主要实现了一个数据结构，List,先进先出。

 

#include "list.h"

void init(struct List * p_list){
	
	memset(p_list->buffer,'\0',10);
	p_list->cursor=(p_list->buffer)+10;
	p_list->begin=p_list->buffer;
	p_list->end=(p_list->buffer)+10;
	
	
}
int get_buffer_length(struct List * p_list){
	
	return p_list->end-p_list->cursor;
}

void put_into_buffer(struct List * p_list,char * pc_char){
	printf("put ........  %c\n",*pc_char);
	if(p_list->cursor<=p_list->begin||p_list->cursor>p_list->end)
		printf(" put error");
	//put the char into cursor's former place
	(p_list->cursor)--;
	memset(p_list->cursor,(int)(*pc_char),1);
	
	
	
}

char get_from_buffer(struct List * p_list){
	if(p_list->cursor<p_list->begin||p_list->cursor>p_list->end)
		printf(" get error");
	//put the char into cursor's former place
	char result=*(p_list->cursor);
	(p_list->cursor)++;
	printf("get ......... %c\n",result);
	return result;
}

 List的具体实现。

 

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

pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

//define the Producer thread
void * produce(void * arg)
{
	//arg is a char * pointer
	struct List * p_list=(struct List *)arg;
	//if buffer length =10,than wait,because buffer is full,
	
	while(1)
	{
		pthread_mutex_lock(&lock);  //正确位置，
		printf("111111\n");
		if(get_buffer_length(p_list)==10)
		{
			printf("22222222\n");
			int num1=pthread_cond_wait(&has_product, &lock);
			printf("33333333\n");
			printf(" num11111 %d\n",num1);
				
		}
		//buffer'length !=10,not full, we can put char into buffer.
		printf("444444\n");
		//pthread_mutex_lock(&lock); //错误位置
		printf("555555\n");
		char zifu=(char)(1+(int)(128.0*rand()/(RAND_MAX+1.0)));
		put_into_buffer(p_list,&zifu);
		//after put, if the length>0,we can notify the wait thread,means that you can get char now
		if(get_buffer_length(p_list)==1)
		{
			pthread_cond_signal(&has_product);	
			printf("66666\n");
		}
		printf("777777777777\n");
		int num3=pthread_mutex_unlock(&lock);
		printf("unlocknumber  1111111111111 is %d\n",num3);
		printf("888888888888\n");
		sleep(1);
	    printf("99999999\n");
   }
	
}

//define the second thread
void * comsume(void * arg)
{	
	//arg is a char * pointer
	struct List * p_list=(struct List *)arg;
	while(1)
	{
		//if buffer length =10,than wait,because buffer is full,
		pthread_mutex_lock(&lock);  //正确位置，
		printf("aaaaaaaaaa\n");
		if(get_buffer_length(p_list)==0)
		{
			printf("bbbbbbbbbbbbbb\n");
			int num2=pthread_cond_wait(&has_product, &lock);
			printf("cccccccccccc\n");				
			printf(" num2222 %d\n",num2);
				
		}
		//buffer'length !=0,not full, we can get char into buffer.
		printf("dddddddddddddddd\n");
		//int num4=pthread_mutex_lock(&lock); //错误位置
		//printf("unlocknumber 222222222 is %d\n",num4);
		printf("eeeeeeeeeeeeee\n");
		char zifu=get_from_buffer(p_list);
		//after get, if the length<10,we can notify the put thread,means that you can put now!
		if(get_buffer_length(p_list)<10)
		{
			pthread_cond_signal(&has_product);	
		}
		printf("ffffffffffff\n");
		pthread_mutex_unlock(&lock);
		printf("gggggggggggg\n");
	    sleep(2);
	    printf("hhhhhhhhhhhhhh\n");
   }
	
}

int main (int argc, char ** argv)
{
	pthread_t tidA, tidB;
    struct List common;
    init(&common);
	
	pthread_create(&tidB, NULL, &comsume, &common);
	
	sleep(3);
	
	pthread_create(&tidA, NULL, &produce, &common);
	sleep(120);
	
	
	return 0;
}

 这个是具体的模型实现，特别注意的是produce和consume方法里面，我注释了，加锁的正确位置和错误位置。如果加锁的位置在错误位置会引起死锁，具体方法，还是用“颜色”分析方法。

首先cosumer进行wait,使其在mutex上进入等待队列，线程切换到produce线程上面执行，然后produce释放锁，consumer居然又要lock mutex，所以互斥，consumer线程就死了，然后produce循环过来，也要lock mutex，所以produce线程也死了。就这样，正确lock mutex位置在文中进行了标注。