线程封装与互斥

线程互斥

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

互斥量mutex

互斥量的接口

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

销毁互斥量

互斥量加锁和解锁

改进售票系统

互斥量实现原理探究

互斥量的封装

线程互斥

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

临界资源：多线程执行流共享的资源就叫做临界资源
临界区：每个线程内部，访问临界资源的代码，就叫做临界区
互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

互斥量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;}}return nullptr;
}
int main()
{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);return 0;
}

上述代码用多线程模拟抢票，但是为什么抢到负数？？？

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

if判断只是对票数进行判断，在cpu内进行逻辑运算，当某个线程刚载入cpu内判断时间片到了就被替换成下一个线程，这样的线程不止一个，再次调度回来时才对--ticket，调度多了，连着减，减成了负数
2.usleep 这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码
段

计算机的运行速度很快，1毫秒内抢票很快，多个线程进入该代码陷入内核线程又被挂起
3.--ticket 操作本身就不是一个原子操作

在计算机内部，--tecket简单分为三步骤：操作要把数据从内存加载到cpu，然后cpu进行计算，最后再把结束写回内存。宏观上是cpu在进行调度，假如cpu调度时时间片到了，进程阻塞挂起时，把该线程的上下文保存，在下一次调度时拷贝回继续运行，在此期间还有别的线程在抢票，不断得对ticket操作，ticket不断减少，但是上一次还没有调度完的线程继续切回来，上一次上下文运行的结果又写回内存，此时ticket的数值反而又会增大

全局资源没有被保护，可能会有并发问题，也就是线程安全。要解决以上问题，需要做到三点：

代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。

要做到这三点，本质上就是需要一把锁，在内核态返回用户态时进行检查。Linux上提供的这把锁叫互斥量。

互斥量的接口

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

定义锁
方法1，静态分配:

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

方法2，动态分配:

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

销毁互斥量

释放锁

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

销毁互斥量需要注意：

使用PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁，全局的锁程序结束自动释放，局部锁才需要手动释放
不要销毁一个已经加锁的互斥量
已经销毁的互斥量，要确保后面不会有线程再尝试加锁

互斥量加锁和解锁

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 <iostream>
#include <string.h>
int ticket = 100;class ThreadDate
{
public:ThreadDate(const std::string &n, pthread_mutex_t &lock): name(n), lockp(&lock) {}~ThreadDate() {}std::string name;pthread_mutex_t *lockp;
};
void *route(void *arg)
{ThreadDate *td = static_cast<ThreadDate *>(arg);while (1){pthread_mutex_lock(td->lockp); // 加锁if (ticket > 0){usleep(1000);                                             // 模拟抢票printf("%s sells ticket:%d\n", td->name.c_str(), ticket); // 抢到票ticket--;pthread_mutex_unlock(td->lockp); // 用完解锁}else{pthread_mutex_unlock(td->lockp); // 票抢完了，解锁退出，否则线程一直阻塞break;}}return nullptr;
}
int main()
{pthread_mutex_t lock;pthread_mutex_init(&lock, nullptr); // 初始化锁pthread_t t1, t2, t3, t4;ThreadDate *td1 = new ThreadDate("thread 1", lock);pthread_create(&t1, NULL, route, (void *)td1);ThreadDate *td2 = new ThreadDate("thread 2", lock);pthread_create(&t2, NULL, route, (void *)td2);ThreadDate *td3 = new ThreadDate("thread 3", lock);pthread_create(&t3, NULL, route, (void *)td3);ThreadDate *td4 = new ThreadDate("thread 4", lock);pthread_create(&t4, NULL, route, (void *)td4);pthread_join(t1, NULL);pthread_join(t2, NULL);pthread_join(t3, NULL);pthread_join(t4, NULL);pthread_mutex_destroy(&lock); // 销毁锁return 0;
}

全局锁

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <iostream>
#include <string.h>
int ticket = 100;pthread_mutex_t glock =PTHREAD_MUTEX_INITIALIZER;//全局初始化
class ThreadDate
{
public:ThreadDate(const std::string &n, pthread_mutex_t &lock): name(n), lockp(&lock) {}~ThreadDate() {}std::string name;pthread_mutex_t *lockp;
};
void *route(void *arg)
{ThreadDate *td = static_cast<ThreadDate *>(arg);while (1){pthread_mutex_lock(&glock); // 加锁if (ticket > 0){usleep(1000);                                             // 模拟抢票printf("%s sells ticket:%d\n", td->name.c_str(), ticket); // 抢到票ticket--;pthread_mutex_unlock(&glock); // 用完解锁}else{pthread_mutex_unlock(&glock);  // 票抢完了，解锁退出，否则线程一直阻塞break;}}return nullptr;
}
int main()
{pthread_mutex_t lock;pthread_t t1, t2, t3, t4;ThreadDate *td1 = new ThreadDate("thread 1", lock);pthread_create(&t1, NULL, route, (void *)td1);ThreadDate *td2 = new ThreadDate("thread 2", lock);pthread_create(&t2, NULL, route, (void *)td2);ThreadDate *td3 = new ThreadDate("thread 3", lock);pthread_create(&t3, NULL, route, (void *)td3);ThreadDate *td4 = new ThreadDate("thread 4", lock);pthread_create(&t4, NULL, route, (void *)td4);pthread_join(t1, NULL);pthread_join(t2, NULL);pthread_join(t3, NULL);pthread_join(t4, NULL);return 0;
}

互斥量实现原理探究

锁的原理

1硬件实现：关闭时钟中断

2.软件实现：为了实现互斥锁操作，大多数体系结构都提供了swap或exchange指令，该指令的作用是把寄存器和内存单元的数据相交换

经过上面的例子，大家已经意识到单纯的 i++ 或者 ++i 都不是原子的，有可能会有数据一致性问题为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的总线周期也有先后,一个处理器上的交换指令执行时另⼀个处理器的交换指令只能等待总线周期。现在我们把lock和unlock的伪代码改一下

锁的初始化把mutex初始化为1，申请锁的时候先把0写进al，然后交换 al和mutex锁的数据，此时%al里面是1，mutex是0，申请锁成功在返回，然后访问临界资源，时间片到了，挂起放到调度队列里了，也没有关系，锁还没有释放，上下文数据被带走了。其他的线程都执行move，寄存器和mutex内都是0，交换完还是0，全部进了下一个调度队列，直到拥有锁的线程执行完释放锁，把1写回mutex，才能轮到下一个线程申请锁成功，如果没有申请成功，锁被占用了，执行else挂起等待，等拥有锁的释放锁后，才可以执行后面的代码申请锁区访问临界支援，说白了，谁交换走了1，谁就持有锁，谁就有优先访问临界资源的权力

互斥量的封装

1.0

//Mutex.hpp#include <pthread.h>
#include <iostream>
namespace MutexModule
{class Mutex{public:Mutex(){pthread_mutex_init(&_mutex, nullptr);}void Lock(){int n = pthread_mutex_lock(&_mutex);(void)n;}void Unlock(){int n = pthread_mutex_unlock(&_mutex);(void)n;}~Mutex(){pthread_mutex_destroy(&_mutex);}private:pthread_mutex_t _mutex;};
}

//TextMutex.cc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <iostream>
#include <string.h>
#include "Mutex.hpp"
using namespace MutexModule;
int ticket = 100;pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER; // 全局初始化
class ThreadDate
{
public:ThreadDate(const std::string &n, Mutex &lock): name(n), lockp(&lock) {}~ThreadDate() {}std::string name;Mutex *lockp;
};
void *route(void *arg)
{ThreadDate *td = static_cast<ThreadDate *>(arg);while (1){td->lockp->Lock(); // 加锁if (ticket > 0){usleep(1000);                                             // 模拟抢票printf("%s sells ticket:%d\n", td->name.c_str(), ticket); // 抢到票ticket--;td->lockp->Unlock(); // 用完解锁}else{td->lockp->Unlock();; // 票抢完了，解锁退出，否则线程一直阻塞break;}}return nullptr;
}
int main()
{Mutex lock;pthread_t t1, t2, t3, t4;ThreadDate *td1 = new ThreadDate("thread 1", lock);pthread_create(&t1, NULL, route, (void *)td1);ThreadDate *td2 = new ThreadDate("thread 2", lock);pthread_create(&t2, NULL, route, (void *)td2);ThreadDate *td3 = new ThreadDate("thread 3", lock);pthread_create(&t3, NULL, route, (void *)td3);ThreadDate *td4 = new ThreadDate("thread 4", lock);pthread_create(&t4, NULL, route, (void *)td4);pthread_join(t1, NULL);pthread_join(t2, NULL);pthread_join(t3, NULL);pthread_join(t4, NULL);return 0;
}

2.0


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <iostream>
#include <string.h>
#include "Mutex.hpp"
using namespace MutexModule;
int ticket = 100;pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER; // 全局初始化
class ThreadDate
{
public:ThreadDate(const std::string &n, Mutex &lock): name(n), lockp(&lock) {}~ThreadDate() {}std::string name;Mutex *lockp;
};
void *route(void *arg)
{ThreadDate *td = static_cast<ThreadDate *>(arg);while (1){LockGuard guard(*td->lockp);if (ticket > 0){usleep(1000);                                             // 模拟抢票printf("%s sells ticket:%d\n", td->name.c_str(), ticket); // 抢到票ticket--;}else{td->lockp->Unlock();break;}}return nullptr;
}
int main()
{Mutex lock;pthread_t t1, t2, t3, t4;ThreadDate *td1 = new ThreadDate("thread 1", lock);pthread_create(&t1, NULL, route, (void *)td1);ThreadDate *td2 = new ThreadDate("thread 2", lock);pthread_create(&t2, NULL, route, (void *)td2);ThreadDate *td3 = new ThreadDate("thread 3", lock);pthread_create(&t3, NULL, route, (void *)td3);ThreadDate *td4 = new ThreadDate("thread 4", lock);pthread_create(&t4, NULL, route, (void *)td4);pthread_join(t1, NULL);pthread_join(t2, NULL);pthread_join(t3, NULL);pthread_join(t4, NULL);return 0;
}


#include <pthread.h>
#include <iostream>
namespace MutexModule
{class Mutex{public:Mutex(){pthread_mutex_init(&_mutex, nullptr);}void Lock(){int n = pthread_mutex_lock(&_mutex);(void)n;}void Unlock(){int n = pthread_mutex_unlock(&_mutex);(void)n;}~Mutex(){pthread_mutex_destroy(&_mutex);}private:pthread_mutex_t _mutex;};class LockGuard{public:LockGuard(Mutex &mutex):_mutex(mutex){_mutex.Lock();}~LockGuard(){_mutex.Unlock();}private:Mutex &_mutex;};
}