进程线程知识之线程同步

• 线程同步原因
• 互斥锁
• 信号量
• 条件变量
• 读写锁

1、线程同步原因

线程同步是为了对共享资源的访问进行保护，目的是为了解决数据一致性的问题。

出现数据一致性问题本质在于进程中的多个线程对共享资源的并发访问（同时访问）。

为确保不会出现对共享资源的并发访问，Linux系统提供了多种实现线程同步的机制，常见的有互斥锁、条件变量、自旋锁以及读写锁等。

2、互斥锁

互斥锁（mutex）又叫做互斥量，在访问共享资源之前对互斥锁进行上锁，在访问完成后释放互斥锁。对互斥锁进行上锁之后，任何其它试图再次对互斥锁进行加锁的线程都会被阻 塞，直到当前线程释放互斥锁。如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒， 它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能 再次陷入阻塞，等待下一次解锁。

#include 
#include 
#include  
#include 
#include 
 
static pthread_mutex_t mutex; 
static int g_count = 0;
 
static void *new_thread_start(void *arg)
{
	int loops = *((int*)arg);
	int l_count, j;
	
	for(j = 0; j < loops; j++)
	{
		//pthread_mutex_lock(&mutex);    //互斥锁上锁 
		
		while(pthread_mutex_trylock(&mutex));   //以非阻塞方式上锁 
		
		l_count = g_count;
		l_count ++;
		g_count = l_count;
		
		pthread_mutex_unlock(&mutex);   //互斥锁解锁 
	}
	
	return (void*)0;
}
 
static int loops;
 
int main(int argc, char *agrv[])
{
	pthread_t tid1, tid2;
	int ret;
	
	/* 获取用户传递的参数 */
//	if(2 > argc) 
//	{
//		loops = 10000000;
//	}
//	else
//	{
//		loops = atoi(argv[1]);
//	}
	
	loops = 10000000;
	
	
	//初始化互斥锁
	pthread_mutex_init(&mutex, NULL); 
	
	/* 创建2个新线程 */
	/* 线程指针； 线程属性； 线程运行函数起始地址； 运行函数的参数*/
	ret = pthread_create(&tid1, NULL, new_thread_start, &loops);
	if(ret)
	{
		fprintf(stderr, "pthread_creadte error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	ret = pthread_create(&tid2, NULL, new_thread_start, &loops);
	if(ret)
	{
		fprintf(stderr, "pthread_creadte error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	/* 等待线程结束 */
	ret = pthread_join(tid1, NULL);
	if(ret)
	{
		fprintf(stderr, "pthread_join error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	ret = pthread_join(tid2, NULL);
	if(ret)
	{
		fprintf(stderr, "pthread_join error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	
	/*打印结果*/
	printf("g_count = %d\n", g_count);
	
	//进程执行完之前销毁互斥锁 
	pthrea_mutex_destroy(&mutex); 
	
	exit(0);
}

3、条件变量

条件变量用于自动阻塞线程，直到某个特定事件或者某个条件满足为止，通常情况下，条件变量和互斥锁一起搭配使用。使用条件变量包含两个动作：

1）一个线程等待某个条件满足而被阻塞；

2）另一个线程中，条件满足时发出“信号”。

生产者—消费者，使用条件变量和互斥锁实现线程同步

#include 
#include 
#include  
#include 
#include 
 
static pthread_mutex_t mutex;   //定义互斥锁
static pthread_cond_t cond;     //定义条件变量 
static int g_avail = 0;         //全局共享资源 
 
 
//消费者线程 
static void *consumer_thread(void *arg)
{
	for(int i=0; i<10; i++)
	{
		pthread_mutex_lock(&mutex);    //互斥锁上锁 
		
		while(0 > g_avail)
		{
			pthread_cond_wait(&cond, &mutex); //等待条件满足 
		}
		
		while(0 < g_avail)     //消费 
		{
			g_avail--;
			printf("consumer_thread: g_avail = %d\n", g_avail);
		}
		
		pthread_mutex_unlock(&mutex);   //互斥锁解锁 
	}
	
	return (void*)0;
}
 
 
//主线程（生产者） 
int main(int argc, char *agrv[])
{
	pthread_t tid;
	int ret;
	
	//初始化互斥锁和条件变量 
	pthread_mutex_init(&mutex, NULL); 
	pthread_cond_init(&cond, NULL); 
	
	/* 创建线程 */
	/* 线程指针； 线程属性； 线程运行函数起始地址； 运行函数的参数*/
	ret = pthread_create(&tid, NULL, consumer_thread, NULL);
	if(ret)
	{
		fprintf(stderr, "pthread_creadte error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	for(int i=0; i<10; i++)
	{
		pthread_mutex_lock(&mutex);     //上锁
		g_avail++;                      //生产
		printf("product_thread: g_avail = %d\n", g_avail);
		pthread_mutex_unlock(&mutex);   //解锁
		pthread_cond_signal(&cond);     //向条件变量发信号 
	}
	
	exit(0);
}

4、自旋锁

自旋锁和互斥锁很相似，在访问共享资源之前对自旋锁进行上锁，在访问完成后释放自旋锁（解锁）。自旋锁较于互斥锁来说更加底层。

如果在获取自旋锁时，自旋锁处于未锁定状态，那么将立即获得锁（对自旋锁进行上锁）；如果在获取自旋锁时，自旋锁已经处于锁定状态，那么获取所操作将会在原地“自旋”，知道该自旋锁的持有者释放了锁。

不同点：

1）互斥锁在无法获得锁时会让线程陷入阻塞等待状态，而自旋锁在无法获取到锁时，将会在原地自旋等待；

2）对同一自旋锁两次加锁必然导致死锁，而对同一互斥锁两次加锁不一定导致死锁（互斥锁有所种类型）。

自旋——调用者一直在循环查看该自旋锁的持有者是否已经释放了锁。

不足：一直占用CPU，致使CPU效率降低。

应用：内核代码中使用较多，在中断服务函数中可以使用。

#include 
#include 
#include  
#include 
#include 
 
static pthread_spinlock_t spin;   //定义自旋锁 
static int g_count = 0;
 
static void *new_thread_start(void *arg)
{
	int loops = *((int*)arg);
	int l_count, j;
	
	for(j = 0; j < loops; j++)
	{
		pthread_spin_lock(&spin);    //自旋锁上锁 
		
		l_count = g_count;
		l_count ++;
		g_count = l_count;
		
		pthread_spin_unlock(&spin);   //自旋锁解锁 
	}
	
	return (void*)0;
}
 
static int loops;
int main(int argc, char *agrv[])
{
	pthread_t tid1, tid2;
	int ret;
	
	/* 获取用户传递的参数 */
//	if(2 > argc) 
//	{
//		loops = 10000000;
//	}
//	else
//	{
//		loops = atoi(argv[1]);
//	}
	
	loops = 10000000;
	
	
	//初始化自旋锁 
	pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE); 
	
	/* 创建2个新线程 */
	/* 线程指针； 线程属性； 线程运行函数起始地址； 运行函数的参数*/
	ret = pthread_create(&tid1, NULL, new_thread_start, &loops);
	if(ret)
	{
		fprintf(stderr, "pthread_creadte error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	ret = pthread_create(&tid2, NULL, new_thread_start, &loops);
	if(ret)
	{
		fprintf(stderr, "pthread_creadte error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	/* 等待线程结束 */
	ret = pthread_join(tid1, NULL);
	if(ret)
	{
		fprintf(stderr, "pthread_join error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	ret = pthread_join(tid2, NULL);
	if(ret)
	{
		fprintf(stderr, "pthread_join error:%s\n", strerror(ret));
		exit(-1);
	} 
	
	
	/*打印结果*/
	printf("g_count = %d\n", g_count);
	
	//进程执行完之前销毁自旋锁 
	pthread_spin_destroy(&spin); 
	
	exit(0);
}

5、读写锁

读写锁（共享互斥锁）有多种状态：读模式下的加锁状态（以下简称读加锁状态）、写模式下的加锁状态（以下简称写加锁状态）和 不加锁状态，一次只有一个线程可以占有写模式的读写锁，但是可以有多个线程同时占有读模式的读写锁。——更高的并行性

规则：

1）当读写锁处于写加锁状态时，在这个锁被解锁之前，所有试图对这个锁进行加锁操作（不管是以读 模式加锁还是以写模式加锁）的线程都会被阻塞。

2） 当读写锁处于读加锁状态时，所有试图以读模式对它进行加锁的线程都可以加锁成功；但是任何以 写模式对它进行加锁的线程都会被阻塞，直到所有持有读模式锁的线程释放它们的锁为止。

读写锁非常适合于对共享数据读的次数远大于写的次数的情况

#include 
#include 
#include  
#include 
#include 
 
static pthread_rwlock_t rwlock;   //定义读写锁 
static int g_count = 0;
 
static void *read_thread(void *arg)
{
	int number = *((int*)arg);
	int j;
	
	for(j = 0; j < 10; j++)
	{
		pthread_rwlock_rdlock(&rwlock);    //以读模式获取锁 
		
		printf("读线程<%d>,g_count=%d\n", number+1, g_count);
		
		pthread_rwlock_unlock(&rwlock);   //解锁 
		sleep(1);
	}
	
	return (void*)0;
}
 
 
static void *write_thread(void *arg)
{
	int number = *((int*)arg);
	int j;
	
	for(j = 0; j < 10; j++)
	{
		pthread_rwlock_wrlock(&rwlock);    //以写模式获取锁 
		
		printf("写线程<%d>,g_count=%d\n", number+1, g_count+=20);
		
		pthread_rwlock_unlock(&rwlock);   //解锁 
		sleep(1);
	}
	
	return (void*)0;
}
 
static int nums[5] = {0, 1, 2, 3, 4};
int main(int argc, char *agrv[])
{
	pthread_t tid[10];
	int j;
	
	
	//初始化读写 
	pthread_rwlock_init(&rwlock, NULL); 
	/* 线程指针； 线程属性； 线程运行函数起始地址； 运行函数的参数*/
	/* 创建5个读g_count变量的线程 */
	for(j = 0; j<5;j++)
	{
		pthread_create(&tid[j], NULL, read_thread, &nums[j]);
	} 
	
	/* 创建5个写g_count变量的线程 */
	for(j = 0; j<5;j++)
	{
		pthread_create(&tid[j+5], NULL, write_thread, &nums[j]);
	} 
	
	/* 等待线程结束 */
	for(j = 0; j < 10; j++)
	{
		pthread_join(tid[j], NULL);  //回收线程 
	}
	
	
	//进程执行完之前销毁读写锁 
	pthread_rwlock_destroy(&rwlock); 
	
	exit(0);
}