Linux 详谈线程同步与互斥

目录

1. 线程互斥

进程线程间的互斥相关背景概念

互斥量mutex

互斥量实现原理探究

互斥量的封装

2. 线程同步

条件变量

同步概念与竞态条件

条件变量函数

---

1. 线程互斥

进程线程间的互斥相关背景概念

临界资源：多线程执⾏流共享的资源就叫做临界资源

临界区：每个线程内部，访问临界资源的代码，就叫做临界区

互斥：任何时刻，互斥保证有且只有⼀个执⾏流进⼊临界区，访问临界资源，通常对临界资源起保护作⽤

原⼦性（后⾯讨论如何实现）：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

互斥量mutex

⼤部分情况，线程使⽤的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程⽆法获得这种变量。

但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

多个线程并发的操作共享变量，会带来⼀些问题。

// 操作共享变量会有问题的售票系统代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
int ticket = 100;

void* route(void* arg)
{
	char* id = (char*)arg;
	while (1) {
		if (ticket > 0) {
			usleep(1000);
			printf("%s sells ticket:%d\n", id, ticket);
			ticket--;
		}
		else {
			break;
		}
	}
}
int main(void)
{
	pthread_t t1, t2, t3, t4;
	pthread_create(&t1, NULL, route, "thread 1");
	pthread_create(&t2, NULL, route, "thread 2");
	pthread_create(&t3, NULL, route, "thread 3");
	pthread_create(&t4, NULL, route, "thread 4");
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	pthread_join(t3, NULL);
	pthread_join(t4, NULL);
}

⼀次执⾏结果：
thread 4 sells ticket:100
...
thread 4 sells ticket:1
thread 2 sells ticket:0
thread 1 sells ticket:-1
thread 3 sells ticket:-2

为什么可能⽆法获得争取结果？

if 语句判断条件为真以后，代码可以并发的切换到其他线程

usleep 这个模拟漫⻓业务的过程，在这个漫⻓的业务过程中，可能有很多个线程会进⼊该代码段

--ticket 操作本⾝就不是⼀个原⼦操作

取出ticket--部分的汇编代码
objdump -d a.out > test.objdump
152 40064b: 8b 05 e3 04 20 00 mov 0x2004e3(%rip),%eax #600b34 <ticket>
153 400651: 83 e8 01 sub $0x1,%eax
154 400654: 89 05 da 04 20 00 mov %eax,0x2004da(%rip) #600b34 <ticket>

-- 操作并不是原⼦操作，⽽是对应三条汇编指令：

load ：将共享变量ticket从内存加载到寄存器中

update : 更新寄存器⾥⾯的值，执⾏-1操作

store ：将新值，从寄存器写回共享变量ticket的内存地址

要解决以上问题，需要做到三点：

代码必须要有互斥⾏为：当代码进⼊临界区执⾏时，不允许其他线程进⼊该临界区。

如果多个线程同时要求执⾏临界区的代码，并且临界区没有线程在执⾏，那么只能允许⼀个线程进⼊该临界区。

如果线程不在临界区中执⾏，那么该线程不能阻⽌其他线程进⼊临界区。

要做到这三点，本质上就是需要⼀把锁。Linux上提供的这把锁叫互斥量。

互斥量的接⼝

初始化互斥量

初始化互斥量有两种⽅法：

⽅法1，静态分配:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

⽅法2，动态分配:

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrictattr);
参数：
    mutex：要初始化的互斥量
    attr：NULL

销毁互斥量

销毁互斥量需要注意：

使⽤ PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁

不要销毁⼀个已经加锁的互斥量

已经销毁的互斥量，要确保后⾯不会有线程再尝试加锁

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

调⽤ pthread_ lock 时，可能会遇到以下情况:

互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功

发起函数调⽤时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调⽤会陷⼊阻塞(执⾏流被挂起)，等待互斥量解锁。

改进上⾯的售票系统:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
int ticket = 100;
pthread_mutex_t mutex;
void* route(void* arg)
{
	char* id = (char*)arg;
	while (1) {
		pthread_mutex_lock(&mutex);
		if (ticket > 0) {
			usleep(1000);
			printf("%s sells ticket:%d\n", id, ticket);
			ticket--;
			pthread_mutex_unlock(&mutex);
			// sched_yield(); 放弃CPU
		}
		else {
			pthread_mutex_unlock(&mutex);
			break;
		}
	}
}
int main(void)
{
	pthread_t t1, t2, t3, t4;
	pthread_mutex_init(&mutex, NULL);
	pthread_create(&t1, NULL, route, "thread 1");
	pthread_create(&t2, NULL, route, "thread 2");
	pthread_create(&t3, NULL, route, "thread 3");
	pthread_create(&t4, NULL, route, "thread 4");
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	pthread_join(t3, NULL);
	pthread_join(t4, NULL);
	pthread_mutex_destroy(&mutex);
}

互斥量实现原理探究

经过上⾯的例⼦，⼤家已经意识到单纯的 i++ 或者 ++i 都不是原⼦的，有可能会有数据⼀致性问题

为了实现互斥锁操作,⼤多数体系结构都提供了swap或exchange指令,该指令的作⽤是把寄存器和内存单元的数据相交换,由于只有⼀条指令,保证了原⼦性,即使是多处理器平台,访问内存的 总线周期也有先后,⼀个处理器上的交换指令执⾏时另⼀个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪代码改⼀下

互斥量的封装

-- Lock.hpp --

#pragma once
#include <iostream>
#include <string>
#include <pthread.h>
namespace LockModule
{
	// 对锁进⾏封装，可以独⽴使⽤
	class Mutex
	{
	public:
		// 删除不要的拷⻉和赋值
		Mutex(const Mutex&) = delete;
		const Mutex& operator =(const Mutex&) = delete;
		Mutex()
		{
			int n = pthread_mutex_init(&_mutex, nullptr);
			(void)n;
		}
		void Lock()
		{
			int n = pthread_mutex_lock(&_mutex);
			(void)n;
		}
		void Unlock()
		{
			int n = pthread_mutex_unlock(&_mutex);
			(void)n;
		}
		pthread_mutex_t* GetMutexOriginal() // 获取原始指针
		{
			return &_mutex;
		}
		~Mutex()
		{
			int n = pthread_mutex_destroy(&_mutex);
			(void)n;
		}
	private:
		pthread_mutex_t _mutex;
	};
	// 采⽤RAII⻛格，进⾏锁管理
	class LockGuard
	{
	public:
		LockGuard(Mutex& mutex) :_mutex(mutex)
		{
			_mutex.Lock();
		}
		~LockGuard()
		{
			_mutex.Unlock();
		}
	private:
		Mutex& _mutex;
	};
}

// 抢票的代码就可以更新成为
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include "Lock.hpp"
using namespace LockModule;
int ticket = 1000;
Mutex mutex;
void* route(void* arg)
{
	char* id = (char*)arg;
	while (1)
	{
		LockGuard lockguard(mutex); // 使⽤RAII⻛格的锁
		if (ticket > 0)
		{
			usleep(1000);
			printf("%s sells ticket:%d\n", id, ticket);
			ticket--;
		}
		else
		{
			break;
		}
	}
	return nullptr;
}
int main(void)
{
	pthread_t t1, t2, t3, t4;
	pthread_create(&t1, NULL, route, (void*)"thread 1");
	pthread_create(&t2, NULL, route, (void*)"thread 2");
	pthread_create(&t3, NULL, route, (void*)"thread 3");
	pthread_create(&t4, NULL, route, (void*)"thread 4");
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	pthread_join(t3, NULL);
	pthread_join(t4, NULL);
}

RAII⻛格的互斥锁， C++11也有，⽐如：

std::mutex mtx;

std::lock_guard<std::mutex> guard(mtx);

此处我们仅做封装，⽅便后续使⽤

2. 线程同步

条件变量

当⼀个线程互斥地访问某个变量时，它可能发现在其它线程改变状态之前，它什么也做不了。

例如⼀个线程访问队列时，发现队列为空，它只能等待，只到其它线程将⼀个节点添加到队列中。这种情况就需要⽤到条件变量

同步概念与竞态条件

同步：在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，从⽽有效避免饥饿问题，叫做同步

竞态条件：因为时序问题，⽽导致程序异常，我们称之为竞态条件。在线程场景下，这种问题也不难理解

条件变量函数

初始化

int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrictattr);
参数：
    cond：要初始化的条件变量
    attr：NULL

销毁

int pthread_cond_destroy(pthread_cond_t *cond);

等待条件满⾜

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrictmutex);
参数：
cond：要在这个条件变量上等待
mutex：互斥量，后⾯详细解释

唤醒等待

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

简单案例：

我们先使⽤PTHREAD_COND/MUTEX_INITIALIZER进⾏测试，对其他细节暂不追究

然后将接⼝更改成为使⽤ pthread_cond_init/pthread_cond_destroy 的⽅式，⽅便后续进⾏封装

#include <iostream>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* active(void* arg)
{
	std::string name = static_cast<const char*>(arg);
	while (true) {
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond, &mutex);
		std::cout << name << " 活动..." << std::endl;
		pthread_mutex_unlock(&mutex);
	}
}
int main(void)
{
	pthread_t t1, t2;
	pthread_create(&t1, NULL, active, (void*)"thread-1");
	pthread_create(&t2, NULL, active, (void*)"thread-2");
	sleep(3); // 可有可⽆，这⾥确保两个线程已经在运⾏
	while (true)
	{
		// 对⽐测试
		// pthread_cond_signal(&cond); // 唤醒⼀个线程
		pthread_cond_broadcast(&cond); // 唤醒所有线程
		sleep(1);
	}
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
}

$ ./cond
thread-1 活动...
thread-2 活动...
thread-1 活动...
thread-1 活动...
thread-2 活动...