Linux C编程--线程操作2--线程同步详解

linux线程同步之互斥

#include <stddef.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

#define FALSE 0
#define TRUE 1

void readfun();
void writefun();

char buffer[256];
int buffer_has_item=0;
int retflag=FALSE,i=0;
pthread_mutex_t mutex;

int main()
{
	void *retval;
	pthread_t reader;
	pthread_mutex_init(&mutex,NULL);
	pthread_create(&reader,NULL,(void *)&readfun,NULL);
	writefun();
	pthread_join(reader,&retval);

}

void readfun()
{
	while(1)
	{
		if(retflag)
			return;
		pthread_mutex_lock(&mutex);
		if(buffer_has_item==1)
		{
			printf("%s",buffer);
			buffer_has_item=0;
		}
		pthread_mutex_unlock(&mutex);
	}
}
void writefun()
{
	int i=0;
	while(1)
	{
		if(i==10)
		{
			retflag=TRUE;
			return;
		}
		pthread_mutex_lock(&mutex);
		if(buffer_has_item==0)
		{
			sprintf(buffer,"This is %d\n",i++);
			buffer_has_item=1;
		}
		pthread_mutex_unlock(&mutex);
	}
}

简要说明：

详细说明

#include
<pthread.h>




int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);


int pthread_cond_destroy(pthread_cond_t *cond);




成功则返回0, 出错则返回错误编号.

#include
<pthread.h>




int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);


int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);




成功则返回0, 出错则返回错误编号.

#include
<pthread.h>




int pthread_cond_signal(pthread_cond_t *cond);


int pthread_cond_broadcast(pthread_cond_t *cond);




成功则返回0, 出错则返回错误编号.

#include <stdio.h>
#include <pthread.h>
#define BUFFER_SIZE 4
#define OVER (-1)
struct producers   //定义生产者条件变量的结构
{
	int buffer[BUFFER_SIZE];        //定义缓冲区
	pthread_mutex_t	lock;           //定义访问缓冲区的互斥锁
	int		readpos, writepos;  //读/写的位置
	pthread_cond_t	notempty;       //缓冲区中有数据时的标记
	pthread_cond_t	notfull;        //缓冲区未满的标记
};

//初始化缓冲区
void init(struct producers *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 producers *b, int data)
{
	pthread_mutex_lock(&b->lock);

//当缓冲区为满时等待
	while((b->writepos+1)%BUFFER_SIZE==b->readpos)
	{
		pthread_cond_wait(&b->notfull,&b->lock);

//在返回之前，pthread_cond_wait需要参数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 producers *b)
{
	int data;
	pthread_mutex_lock(&b->lock);

//当缓冲区中无数据时等待
	while(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;
}

struct producers  buffer;
void *producer(void *data)
{
	int n;
	for(n=0;n<10;n++)
	{
		printf("Producer : %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("Consumer: --> %d\n",d);
	}
	return NULL;
}

int main()
{
	pthread_t tha,thb;
	void *retval;
	init(&buffer);
	pthread_create(&tha,NULL,producer,0);
	pthread_create(&thb,NULL,consumer,0);
	pthread_join(tha,&retval);
	pthread_join(thb,&retval);
	return 0;

}

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define BUFFER_SIZE 4
#define OVER (-1)
struct producers
{
	int buffer[BUFFER_SIZE];
	int		readpos, writepos;
	sem_t	sem_read;
	sem_t	sem_write;
};

void init(struct producers *b)
{
	sem_init(&b->sem_write,0,BUFFER_SIZE-1);
	sem_init(&b->sem_read,0,0);
	b->readpos=0;
	b->writepos=0;
}

void put(struct producers *b, int data)
{
	sem_wait(&b->sem_write);
	b->buffer[b->writepos]=data;
	b->writepos++;
	if(b->writepos>=BUFFER_SIZE) b->writepos=0;
	sem_post(&b->sem_read);
}

int get(struct producers *b)
{
	int data;
	sem_wait(&b->sem_read);
	data=b->buffer[b->readpos];
	b->readpos++;
	if(b->readpos>=BUFFER_SIZE) b->readpos=0;
	sem_post(&b->sem_write);
	return data;
}

struct producers  buffer;
void *producer(void *data)
{
	int n;
	for(n=0;n<10;n++)
	{
		printf("Producer : %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("Consumer: --> %d\n",d);
	}
	return NULL;
}

int main()
{
	pthread_t tha,thb;
	void *retval;
	init(&buffer);
	pthread_create(&tha,NULL,producer,0);
	pthread_create(&thb,NULL,consumer,0);
	pthread_join(tha,&retval);
	pthread_join(thb,&retval);
	return 0;

}