Linux线程同步

1.同步

        同步即协同步调，按预定的先后次序运行。

        线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该函数。

解决同步的问题：加锁！

2.数据混乱原因

1.资源共享（独享资源则不会）

2.调度随机（意味着数据访问会出现竞争）

3.线程间缺乏必要的同步机制

以上3点钟，前2点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。只要存在竞争关系，数据就很容易出现混乱。

        所以只能从第三点着手解决，使多个线程在访问共享资源的时候，出现互斥。

void* thr1(void* arg)
{
	while (1)
	{
		printf("hello");
		sleep(rand()%3);
		printf(" word\n");
		sleep(rand()%3);
	}
}

void* thr2(void* arg)
{
	while (1)
	{
		printf("HELLO");
		sleep(rand()%3);
		printf(" WORLD\n");
		sleep(rand()%3);
	}
}

int main(int argc, char* argv[])
{

	pthread_t tid[2];
	pthread_create(&tid[0], NULL, thr1, NULL);
	pthread_create(&tid[0], NULL, thr2, NULL);
	
	pthread_join(tid[0], NULL);
	pthread_join(tid[0], NULL);
	
	exit(0);
}

3.互斥量

#include 

int pthread_mutex_init(pthread_mutex_t *restrict mutex,
           const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

 restrict: 约束该块内存区域对应的数据，只能通过后面你的变量进行访问和修改

mutex: 互斥量 --锁

attr：互斥量的属性，可以不考虑，传NULL

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

mutex: init初始化的锁

如果当前未锁，成功，该线程给加锁。

如果已经加锁，阻塞等待！

摧毁锁：

int pthread_mutex_destroy(pthread_mutex_t *mutex);

static pthread_mutex_t s_mutex;

void* thr1(void* arg)
{
	while (1)
	{
		pthread_mutex_lock(&s_mutex);
		printf("hello");
		printf(" word\n");
		pthread_mutex_unlock(&s_mutex);		
		sleep(rand()%3);
	}
}

void* thr2(void* arg)
{
	while (1)
	{
		pthread_mutex_lock(&s_mutex);
		printf("HELLO");
		printf(" WORLD\n");
		pthread_mutex_unlock(&s_mutex);
		sleep(rand()%3);
	}
}

int main(int argc, char* argv[])
{

	pthread_t tid[2];
	
	pthread_mutex_init(&s_mutex, NULL);

	pthread_create(&tid[0], NULL, thr1, NULL);
	pthread_create(&tid[0], NULL, thr2, NULL);
	
	pthread_join(tid[0], NULL);
	pthread_join(tid[0], NULL);
	pthread_mutex_destroy(&s_mutex);
	exit(0);
}

 互斥量的使用步骤：初始化，加锁，执行逻辑（操作共享数据），解锁

注意事项：

加锁需要最小粒度，不要一直占用临界区

lock和trylock：

lock加锁失败会阻塞，等待锁释放。

trylock加锁失败直接返回错误号（如：EBUSY）， 不阻塞

static pthread_mutex_t s_mutex;

void* thr1(void* arg)
{
	while (1)
	{
		pthread_mutex_lock(&s_mutex);
		printf("hello world\n");
		sleep(3);
		pthread_mutex_unlock(&s_mutex);
		sleep(1);
	}
	return NULL;
}

int main(int argc, char* argv[])
{
	pthread_t tid;
	
	pthread_mutex_init(&s_mutex, NULL);
	pthread_create(&tid, NULL, thr1, NULL);
	sleep(1);
	while (1)
	{
		int ret = pthread_mutex_trylock(&s_mutex);
		if (ret > 0)
		{
			printf("ret = %d, strmsg: %s\n", ret, strerror(ret));
		}
		else if (ret == 0)
		{
			printf("HELLO WORLD\n");
			pthread_mutex_unlock(&s_mutex);
		}
		sleep(1);
	}
	
	pthread_join(tid, NULL);
	pthread_mutex_destroy(&s_mutex);
	exit(0);
}

死锁

        锁了又锁，自己加了一次锁成功，又加了一次

        交叉锁，解决方法：每个线程申请锁的顺序要一直；如果申请到一把锁，申请另外一把的时候申请失败，应该释放

互斥量只是建议锁

4.读写锁

        与互斥量类似，但读写锁允许更高的并行性，其特性为：写独占，读共享，写优先级高。

读写锁具备三种状态：

        1.读模式下加锁状态（读锁）

        2.写模式下加锁状态（写锁）

        3.不加锁状态

读写锁特性：

        1.读写锁是“写模式加锁”时，解锁前，所有对该锁加锁的线程都会被阻塞。

        2.读写锁是“读模式加锁”时，如果线程以读模式对其加锁会成功，如果线程以写模式加锁会阻塞；

        3.读写锁是“读模式加锁”时，既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求，优先满足写模式锁，读锁、写锁并行阻塞，写锁优先级别高；

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

读写锁场景：

1.线程A加写锁成功，线程B请求读锁

线程B阻塞

2.线程A持有读锁，线程B请求写锁

线程B阻塞

3.线程A拥有读锁，线程B请求读锁

B加锁成功

4.线程A持有读锁，然后线程B请求写锁，然后线程C请求读锁

BC阻塞

A释放后，B加锁

B释放后，C加锁

5.线程A持有写锁，然后线程B请求读锁，然后线程C请求写锁

BC阻塞

A释放，C加锁

C释放，B加锁

// 初始化读写锁
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                        const pthread_rwlockattr_t *restrict attr);
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

// 销毁读写锁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

// 加读锁
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

// 加写锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

// 释放锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

int beginNum = 1000;

void* thr_write(void* arg)
{
	while (1)
	{
		pthread_rwlock_wrlock(&rwlock);
		printf("----%s----self---%lu----beginNum---%d\n", __FUNCTION__, pthread_self(), ++beginNum);
		usleep(2000); // 模拟占用时间
		pthread_rwlock_unlock(&rwlock);
		usleep(50000);
	}
	return NULL;
}

void* thr_read(void* arg)
{
	while (1)
	{
		pthread_rwlock_rdlock(&rwlock);
		printf("----%s----self---%lu----beginNum---%d\n", __FUNCTION__, pthread_self(), beginNum);
		usleep(2000); // 模拟占用时间
		pthread_rwlock_unlock(&rwlock);
		usleep(2000);
	}
	return NULL;
}

int main(int argc, char* argv[])
{
	pthread_t tid[8];
	int n = 8, i = 0;

	for (size_t i = 0; i < 5; i++)
	{
		pthread_create(&tid[i], NULL, thr_read, NULL);
	}
	for (; i < n; i++)
	{
		pthread_create(&tid[i], NULL, thr_write, NULL);
	}
	
	for (size_t i = 0; i < n; i++)
	{
		pthread_join(tid[i], NULL);
	}
	
	pthread_rwlock_destroy(&rwlock);
	exit(0);
}

5.条件变量

条件变量的优点：

相较于mutex而言，条件变量可以减少竞争

如直接使用mutex，除了生产者，消费者之间要竞争互斥量以外，消费者之间也需要竞争互斥量，但如果汇聚（链表）中没有数据，消费者之间竞争互斥锁是无意义的。有了条件变量机制以后，只有生产者完成生产，才会引起消费者之间的竞争。提高了程序效率。

pthread_cond_init函数

初始化一个条件变量

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

pthread_cond_destroy函数 

int pthread_cond_destroy(pthread_cond_t *cond);

pthread_cond_wait函数

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

阻塞等待一个条件变量

函数作用：

1.阻塞等待条件变量cond(参数1)满足

2.释放已掌握的互斥锁（解锁互斥量）相当于pthread_mutex_unlock(&mutex)

        1.2.两步为一个原子操作

3.当被唤醒，pthread_cond_wait函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex)

pthread_cond_timedwait函数

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

参数3：参看man sem_timedwait函数，查看struct timespec结构体

           struct timespec {
               time_t tv_sec;      /* Seconds */  秒
               long   tv_nsec;     /* Nanoseconds [0 .. 999999999] */ 纳秒
           };
形参abstime：绝对时间

        如：time(NULL)返回的就是绝对时间，而alarm(1)是相对时间，相对当前时间为秒钟

tv_sec 绝对时间，填写的时候time(NULL)+600 ==》设置超时600s

1.先释放锁

2.阻塞在cond条件变量上

pthread_cond_signal函数

唤醒至少一个阻塞在条件变量cond上的线程

int pthread_cond_signal(pthread_cond_t *cond);

pthread_cond_broadcast函数

唤醒阻塞在条件变量cond上全部线程

int pthread_cond_broadcast(pthread_cond_t *cond);

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int beginNum = 1000;

typedef struct _ProdInfo
{
	int num;
	int size;
	struct _ProdInfo *next;
}ProdInfo;
ProdInfo *Head = NULL;

void* thr_producter(void* arg)
{
	// 负责在链表添加数据
	while (1)
	{
		ProdInfo* prod = malloc(sizeof(ProdInfo));
		prod->num = beginNum++;
		printf("--%s---self=%lu---%d\n", __FUNCTION__, pthread_self(), prod->num);
		pthread_mutex_lock(&mutex);
		// add a list
		prod->next = Head;  // 头插
		Head = prod;
		pthread_mutex_unlock(&mutex);
		// 发起通知
		pthread_cond_signal(&cond);
		sleep(rand()%2);
	}
	return NULL;
}

void *thr_customer(void* arg)
{
	ProdInfo *prod = NULL;

	while (1)
	{
		// 获取链表的数据
		pthread_mutex_lock(&mutex);
		// if (Head == NULL)
		while(Head == NULL)
		{
			pthread_cond_wait(&cond, &mutex); //在次之前必须先加锁
		}
		prod = Head;  // 取出链表数据
		Head = Head->next; // 从链表删除
		printf("--%s---self=%lu---%d\n", __FUNCTION__, pthread_self(), prod->num);
		pthread_mutex_unlock(&mutex);
		sleep(rand()%4);
		free(prod);
	}	
	
	return NULL;
}

6.信号量

进化版的互斥锁（1->N）

        由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一个对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并发执行，变成了串行执行，与直接使用单进程无异。

        信号量，是相对这种的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。