⼀次执⾏结果：
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);

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

销毁

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);

#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 活动...