linux中多线程解析

核心提示：#define BUFFER_SIZE 8struct prodcons {int buffer[BUFFER_SIZE]; pthread_mutex_t lock; //互斥LOCKint readpos , writepos; pthread_cond_t notempty; //缓冲区非空条件判断

#define BUFFER_SIZE 8

struct prodcons {
int buffer[BUFFER_SIZE];
pthread_mutex_t lock; //互斥LOCK
int readpos , writepos;
pthread_cond_t notempty; //缓冲区非空条件判断
pthread_cond_t notfull; //缓冲区未满条件判断
};

void init(struct prodcons * b){
pthread_mutex_init(&b->lock,NULL);
pthread_cond_init(&b->notempty,NULL);
pthread_cond_init(&b->notfull,NULL);

b->readpos=0;
b->writepos=0;
}

void put(struct prodcons* b,int data){
pthread-_mutex_lock(&b->lock);

if((b->writepos + 1) % BUFFER_SIZE == b->readpos)
{
pthread_cond_wait(&b->notfull, &b->lock) ;
}

b->buffer[b->writepos]=data;
b->writepos++;

if(b->writepos >= BUFFER_SIZE)
b->writepos=0;

pthread_cond_signal(&b->notempty);
pthread_mutex_unlock(&b->lock);
}
int get(struct prodcons *b){
int data;

pthread_mutex_lock(&b->lock);
if(b->writepos == b->readpos)
{
pthread_cond _wait(&b->notempty, &b->lock);
}

data = b->buffer[b->readpos];
b->readpos++;

if(b->readpos >= BUFFER_SIZE)
b->readpos=0;

pthread_cond_signal(&b->notfull);
pthread_mutex_unlock(&b->lock);

return data;
}

#define OVER (-1)
struct prodcons buffer;

void *producer(void *data)
{
int n;

for(n = 0; n < 10000; n++)
{
printf("%d \n", n) ;
put(&buffer, n);
}

put(&buffer, OVER);

return NULL;
}
void *consumer(void * data)
{
int d;

while(1)
{
d = get(&buffer);

if(d == OVER)
break;

printf("%d\n", d);
}

return NULL;
}

int main(void)
{
pthread_t th_a, th_b;

void *retval;

init(&buffer);

pthread_create(&th_a, NULL, producer, 0);
pthread_create(&th_b, NULL, consumer, 0);

pthread_join(th_a, &retval);
pthread_join(th_b, &retval);

return 0;
}

上面的例子中，生产者负责将1到1000的整数写入缓冲区，而消费者负责从同一个缓冲区中读取写入的整数并打印出来。因为生产者和消费者是两个同时运行的线程，并且要使用同一个缓冲区进行数据交换，因此必须利用一种机制进行同步。通过上面的例子我们可以看到，多线程的最大好处是，除堆栈之外，几乎所有的数据均是共享的，因此线程间的通讯效率很高；缺点：因为共享所有数据，从而非常容易导致线程之间互相破坏数据，这一点在编程时必须注意。