线程的同步方法

1、信号量

这里和进程间的信号量作用相似，当线程访问一些有限的共享资源时，就必须做到线程间同步访问。

信号量的使用方式：#include<semaphore.h>

初始化：int sem_init(sem_t *sem,int shared,int val);

信号量sem一般被定义在线程共享的全局数据区，sem_init函数是将信号量sem的初始值设置为val，shared参数控制这个信号量是否可以在多个进程之间共享，但是Linux对此不支持。

P操作：int sem_wait(sem_t *sem);

对信号量sem进行-1操作，如果结果小于0，则此函数调用会阻塞，直到有其他线程执行V操作。

V操作：int sem_pos(sem_t *sem);

对于信号量sem进行+1操作

销毁：int sem_destroy(sem_t *sem);

销毁信号量

#include<string.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
char buff[128]={0};
sem_t sem;
void *fun(void *arg)
{
	while(1)
	{
		sem_wait(&sem);//P操作
		if(strncmp(buff,"end",3)==0)
		{
			break;
		}
		int i=0;
		for(;buff[i]!=0;++i)
		{
			if(buff[i]>='A'&&buff[i]<='Z')
			{
				printf("%c",buff[i]);
			}
			else
			{
				printf("%c",buff[i]-'a'+'A');
			}
		}
		printf("\n");
	}
}
void Destroy()//注册一个销毁函数，进程结束时销毁信号量
{
	printf("Destroy was called\n");
	sem_destroy(&sem);
}
int main()
{
	atexit(Destroy);
	sem_init(&sem,0,0);//初始化
	pthread_t id;
	int res=pthread_create(&id,NULL,fun,NULL);
	assert(res==0);
	while(1)
	{
		printf("please input: ");
		fgets(buff,128,stdin);
		buff[strlen(buff)-1]=0;

		sem_post(&sem);//V操作

		if(strncmp(buff,"end",3)==0)
		{
			break;
		}
	}
}

2、互斥锁

互斥锁又叫互斥量，只有加锁解锁两种状态，只会针对于一个临界资源进行控制。

互斥锁的使用方式：#include<pthread.h>

初始化：int pthread_mutex_init(pthread_mutex_t *mutex,pthread_mutex_t *attr);

互斥锁mutex一般被定义在线程共享的全局数据区，此函数是初始化互斥锁mutex，attr为锁的属性。

加锁：int pthread_mutex_lock(pthread_mutex_t *mutex);

           int pthread_mutex_trylock(pthread_mutex_t *mutex);

解锁：int pthread_mutex_unlock(pthread_mutex_t *mutex);

销毁锁：int pthread_mutex_destroy(pthread_mutex_t *mutex);

 

#include<string.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
char buff[128]={0};
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
void *fun(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
		if(strncmp(buff,"end",3)==0)
		{
			break;
		}
		int i=0;
		for(;buff[i]!=0;++i)
		{
			if(buff[i]>='A'&&buff[i]<='Z')
			{
				printf("%c",buff[i]);
			}
			else
			{
				printf("%c",buff[i]-'a'+'A');
			}
		}
		printf("\n");
		pthread_mutex_unlock(&mutex2);
	}
}
void Destroy()
{
	printf("Destroy was called\n");
	pthread_mutex_destroy(&mutex);
}
int main()
{
	atexit(Destroy);
	pthread_mutex_init(&mutex,NULL);
	pthread_mutex_init(&mutex2,NULL);
	pthread_mutex_lock(&mutex);
	//pthread_mutex_lock(&mutex2);
	pthread_t id;
	int res=pthread_create(&id,NULL,fun,NULL);
	assert(res==0);
	while(1)
	{
		pthread_mutex_lock(&mutex2);
		printf("please input: ");
		fgets(buff,128,stdin);
		buff[strlen(buff)-1]=0;

		pthread_mutex_unlock(&mutex);
		if(strncmp(buff,"end",3)==0)
		{
			break;
		}
	}
}

3、条件变量

与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止，通常条件变量和互斥锁同时使用。

条件变量可以使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待“条件变量的条件成立”而挂起；另一个线程使“条件成立”（给出条件成立信号）。

条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两个进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。

条件变量分为两个部分：条件和变量，条件本身是由互斥量保护的，线程在改变条件状态前先要锁住互斥量，它利用线程共享的全局变量进行同步的一种机制。