【Linux】线程同步

线程同步

一、什么是线程同步
线程同步和进程同步一样都是解决线程之间的竞争关系与协作关系。
线程就像是进程的一个化身，当创建进程去做一些事情的时候，效率有时候并不是很高，系统的负担也会重。这时候就可以用线程来做。
二、线程同步的四种方式
1、互斥量（互斥锁）
（1）概念
锁只有两种方式：加锁和解锁
线程在进入临界区之前，加锁操作
线程在退出临界区之后，解锁操作
如果锁是加锁状态，则执行加锁操作将会阻塞，这就是互斥锁。
锁在解决竞争关系的时候是很方便的。
（2）互斥锁的类型：pthread_mutex_t（一般将锁定义到全局）
（3）互斥锁的操作

• 初始化：int pthread_mutex_init(pthread_mutex_t* mutex, pthread_mutexattr_t *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_destory(pthread_mutex_t * mutex);

（4）练习题：主线程负责接收用户输入，函数线程负责将用户输入打印到终端界面
2、信号量（线程库中的信号量）
（1）概念：特殊的一个计数器
（2）信号量类型：全局 sem_t
（3）信号量的操作

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

shared的值为0.
val:信号量的初始化

• P操作:int sem_wait(sem_t *sem);

如果信号量的值为0，则P操作阻塞

• V操作:int sem_post(sem_t* sem);
• 销毁:int sem_destory(sem_t * sem);

（4）练习题：主线程完成获取用户数据的数据，并存储在全局数组buff中
在Linux中创建线程sem.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <phread.h>
#include <semaphore.h>
sem_t sem1;
sem_t sem2;
char buff[128] = {0};
void* fun(void* arg)
{
	while(1)
	{
		sem_wait(&sem1);
		if(strncmp(buff, "end", 3) == 0)
		{
			break;
		}
		printf("fun: %s",buff);
		memset(buff, 0, 128);
		sem_post(&sem2);//函数线程唤醒主线程的
	}
}
int main()
{
	sem_init(&sem1, 0, 0);
	sem_init(&sem2, 0, 1);
	pthread_t id;
	int res = pthread_create(&id, NULL,fun,NULL);
	assert(0 == res);
	while(1)
	{
		sem_wait(&sem2);
		printf("input: ");
		fgets(buff, 127, stdin);
		sem_post(&sem1);//主线程唤醒函数线程
		if(strncmp(buff, "end", 3) == 0)
		{
			breadk;
		}
	}
	pthread_join(id,NULL);
	sem_destory(&sem1);
	sem_destory(&sem2);
	exit(0);
}

编译后，得到：

这个也是完成了线程同步
3、条件变量
（1）概念：条件变量提供了一种线程间的通知机制：当某个共享数据达到某个值的时候，唤醒等待这个共享数据的线程
（2）操作方法

• 初始化：int pthread_cond_init(pthread_cond_t*cond, pthread_condattr_t * attr);
• 等待:int pthread_cond_wait(pthread_cond_tcond,pthread_mutex_tmutex);

1、 pthread_mutex_lock(&mutex);
2、 pthread_cond_wait(&cond,&mutex);
（1）mutex加锁
（2）wait调用，将线程放到cond现成列表中，然后解锁
（3）wait返回时，mutex又会被锁住
（4）对mutex解锁
3、pthread_mutex_unlock(&mutex);

• 唤醒单个线程：int pthread_cond_signal(pthread_cond_t*cond);
• 唤醒所有等待的线程：int pthread_cond_broadcast(pthread_cond_t * cond);
• 销毁：int pthread_cond_destroy(pthread_cont_t * cond);
  （3）系统实现

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <pthread.h>
char buff[128] = {0};
pthread_cond_t cond;//条件变量
pthread_mutex_t mutex;//互斥锁
void *fun(void*arg)
{
	char* s = (char*)arg;
	while(1)
	{
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
		pthread_mutex_unlock(&mutex);
	}
	if(strncmp(buff, "end", 3) == 0)
	{
		break;
	}
	printf("%s: %s", s, buff);
}
int main()
{
	pthread_mutex_init(&mutex,NULL);
	pthread_cond_init(&cond,NULL);
	pthread_t id[2];
	int res = pthread_creat(&id[0],NULL, fun, "thread1");
	assert(res == 0);
	while(1)
	{
		printf("input: ");
		fgets(buff, 127, stdin);
		if(strncmp(buff, "end", 3) == 0)
		{
			pthread_mutex_lock(&mutex);
			pthread_cond_broadcast(&cond);
			pthread_mutex_unlock(&mutex);
		}
		else
		{
			pthread_mutex_lock(&mutex);
			pthread_cond_signal(&cond);
			pthread_mutex_unlock(&mutex);
		}
	}
	pthread_join(id[0],NULL);
	pthread_join(id[1],NULL);
	pthread_mutex_destroy(&mutex);
	pthread_cond_destory(&cond);
	exit(0);
}

4、读写锁
（1）概念：读写锁与互斥量类似，不过读写锁允许更高的并行性。读写锁可以有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。
（2）操作方法

• 初始化：int pthread_relock_init(pthread_t* rlock,pthread_rwlockattr * attr)；
  -读锁： int pthread_rwlock_rdlock(pthread_rwlock_t *relock);

允许多个线程同时进行读加锁，所有线程都是执行读操作，不会改变数据

• 写锁：int pthread_rwlock_wdlock(pthread_rwlock_t *relock);
• int pthread_rwlock_udlock(pthread_rwlock_t *relock);
• 销毁：int pthread_rwlock_destroypthread_rwlock_t *relock);