Linux线程_线程互斥_线程同步

一.线程互斥

1.进程线程间的互斥相关概念

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

有多个线程对临界资源num=10000进行--操作 直到num==0。如果不进行保护，num为什么会<0?

1.num--操作并不是原子性的，实际上分为三部 1.把数据从内存存入CPU的寄存器 2.数据-- 3.再把寄存器的数据写回内存

2.if(num>0) 也不是原子性的，分为读取和比较操作。如果刚读取完num==1，条件符合，线程1进入，还没进行--就被切换，线程2读取 条件仍符合，线程2进入。这样就可能会放入多个线程进入。

3.让线程尽可能的切换

线程什么时候会被切换？
1.时间片用完
2.高优先级线程抢占当前线程

3.当前线程进入阻塞状态（等待 I/O 或资源）

sleep会让当前线程进入等待队列，并切换其它线程进行调度。等到sleep结束，从内核态转为用户态，会检测时间片是否结束，结束进行切换其它线程。

因此根本原因就在于if(num>0)不是原子性的，让多个线程进入判断内部，导致num<0

2.互斥锁函数

解决上面的问题，就要完成在判断内部也就是临界区内只有一个线程执行。

对临界区进行加锁就可以保证临界区内只有一个线程执行。

下面我们看一下锁的用法

1.PTHREAD_MUTEX_INITIALIZER宏初始化

有两种初始化锁的方法，这是用宏对锁静态初始化。

pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER

定义的时候就完成初始化，通常用于声明全局或静态的互斥锁。

初始化好锁后，怎么用呢？

1.进入临界区前 加锁 

pthread_mutex_lock()

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);

mutex指向要进行加锁操作的锁  成功返回0 失败返回错误码

2.出临界区后 解锁

pthread_mutex_unlock()

int pthread_mutex_unlock(pthread_mutex_t *mutex);

mutex指向要进行解锁操作的锁  成功返回0 失败返回错误码

2.pthread_mutex_init()函数初始化 

 先定义锁，再用函数初始化。适用于局部变量、需要在运行时初始化的互斥锁。

可以传递锁的属性。需要在使用完后调用 pthread_mutex_destroy 销毁。

#include <pthread.h>pthread_mutex_t mutex;  // 声明但不初始化void *thread_func(void *arg) {pthread_mutex_lock(&mutex);  // 加锁// 访问共享资源pthread_mutex_unlock(&mutex);  // 解锁
}int main() {pthread_t thread1, thread2;// 动态初始化互斥锁pthread_mutex_init(&mutex, NULL);  // 初始化互斥锁pthread_create(&thread1, NULL, thread_func, NULL);pthread_create(&thread2, NULL, thread_func, NULL);pthread_join(thread1, NULL);pthread_join(thread2, NULL);pthread_mutex_destroy(&mutex);  // 销毁互斥锁return 0;
}

 pthread_mutex_init()
 

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

mutex 指向要初始化的锁 attr锁的属性

pthread_mutex_destroy()
 

int pthread_mutex_destroy(pthread_mutex_t *mutex);

mutex指向要销毁的锁

每次进出临界区的时候都要进行加锁 解锁操作，有什么办法可以自动对临界区进行加锁 解锁？

#pragma once
#include <iostream>
#include <pthread.h>namespace LockModule
{class Mutex{public:Mutex(const Mutex&) = delete;const Mutex& operator = (const Mutex&) = delete;Mutex(){int n = ::pthread_mutex_init(&_lock, nullptr);(void)n;}~Mutex(){int n = ::pthread_mutex_destroy(&_lock);(void)n;}void Lock(){int n = ::pthread_mutex_lock(&_lock);(void)n;}void Unlock(){int n = ::pthread_mutex_unlock(&_lock);(void)n;}private:pthread_mutex_t _lock;};class LockGuard{public:LockGuard(Mutex &mtx):_mtx(mtx){_mtx.Lock();}~LockGuard(){_mtx.Unlock();}private:Mutex &_mtx;};
}

定义一个Mutex类，它的构造函数就是初始化成员变量_block锁，析构函数是销毁锁。有解锁 加锁的函数。再定义一个以Mutex类对象为成员变量的LockGuard类，构造函数进行加锁操作，析构函数进行解锁操作。这样创建一个LockGuard对象就完成了加锁，销毁时就完成了解锁操作。

我们把临界区单独放在一个作用域里面，在临界区的作用域里面一开始创建LockGuard对象自动调用构造函数完成加锁，等到出作用域自动调用析构函数，完成解锁。

3.互斥量实现原理

pthread_mutex_lock()到底怎么完成只让一个线程进入临界区，实现互斥操作的呢？

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

在内存中互斥锁mutex可以理解成一个计数器，默认为1，代表没有线程在临界区，可以进入。为0代表有线程在临界区不能进入。

进入lock函数:

1.move $0 %al 把0值写入寄存器

2.xchgb 把寄存器数据0和内存mutex数据交换（原子性）

3.如果寄存器内数据>0 代表没有线程在临界区，可以进入。

==0 有线程在临界区，进入等待队列。等待结束后再重新执行lock函数 直到>0返回

unlock函数：

把1写入mutex中 （原子性），退出临界区，表示允许线程进入临界区。

二.线程同步

1.同步概念

互斥可以保证只有一个线程进入临界区访问临界资源，但多个线程竞争同一份临界资源，如果有一个线程总是能访问到，而其它线程一直在等待，这就造成了饥饿问题。怎么才能解决线程间资源的竞争呢？

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

同步的机制有 互斥锁(确保每次只有一个线程能访问临界区，防止并发访问同一资源)

条件变量 (让线程在某个条件满足之前挂起，直到其他线程通知它继续执行)

信号量 (用于控制访问共享资源的线程数量)

条件变量可以协调线程的执行顺序。

2.条件变量函数

初始化

1.PTHREAD_COND_INITIALIZER宏

一般用于初始化全局条件变量

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

2.int pthread_cond_init()
 

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

cond：指向要初始化的条件变量的指针。
attr：用于设置条件变量的属性，一般传入 NULL，表示使用默认属性。
返回值：成功时返回 0，失败时返回错误码。

pthread_cond_destroy()销毁
 

int pthread_cond_destroy(pthread_cond_t *cond);

pthread_cond_wait() 等待条件变量
 

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

cond：条件变量。
mutex：互斥锁，在调用 pthread_cond_wait 时必须持有该锁。调用 wait 会解锁，并使当前线程阻塞，直到条件变量被通知。
返回值：成功时返回 0，失败时返回错误码。
注意：pthread_cond_wait 会解锁并使当前线程阻塞，直到条件变量收到通知，线程被唤醒后，重新加锁。

pthread_cond_signal() 通知一个线程
 

int pthread_cond_signal(pthread_cond_t *cond);

cond：条件变量，通知一个等待该条件变量的线程。
返回值：成功时返回 0，失败时返回错误码。

pthread_cond_broadcast() 通知所有线程
 

int pthread_cond_broadcast(pthread_cond_t *cond);

cond：条件变量，通知所有等待该条件变量的线程。
返回值：成功时返回 0，失败时返回错误码。

3.生产消费者模型

1.什么是生产消费者模型

互斥锁和条件变量怎么搭配使用呢？
先讲一个场景，生产消费者模型。

有多个工厂向超市放资源，超市存入资源且大小有限，消费者从超市拿资源。

可以理解为有多个线程向临界区存入资源，有多个线程从临界区取资源。在此过程中要保证临界区的安全，还有保证高效。

在此场景中有三种关系：

1.生产者和生产者 两个生产者可以同时进入超市吗？不能，如果超市刚好差一个资源就满，那么就不能保证资源安全。

所以生产者和生产者关系为:互斥

2.消费者和消费者 两个消费者可以同时进入超市吗？不能，超市有只有一个资源的情况

所以消费者和消费者关系为:互斥

3.消费者和生产者 一个消费者和一个生产者可以同时进入吗？不能，消费者在取资源时怎么知道生产者有没有放资源，消费者先取发现没有，回去说里面没有资源，生产者再放，回去说里面有资源，造成二义性。

所以消费者和生产者关系为:互斥

消费者发现超市没有资源，就回去，等一段时间再访问有没有资源，不停循环访问。这样虽然合理，但不高效。如果能什么时候有资源了，就通知一声消费者再让它过来就可以了，

那么谁知道什么时候有资源呢？生产者，因为相互互斥，等生产者出来的时候一定有资源，让生产者通知消费者取资源就可以了。反过来，消费者也知道什么时候资源没满，消费者出来的时候，再通知生产者存入资源就可以了。

所以消费者和生产者关系为:互斥+同步

下面我们用代码模拟上述场景，多个线程分别当作生产者 消费者，用阻塞队列当作有资源上线的超市。(当队列为空时，消费者线程会被阻塞，直到队列中有元素可以消费；当队列满时，生产者线程会被阻塞，直到队列中有空位可以插入新的元素。阻塞队列常用于多线程环境中的生产者-消费者问题等场景。)

2.代码模拟

#pragma once#include<iostream>
#include<cstdio>
#include<queue>
#include "Mutex.hpp"
#include "Cond.hpp"using namespace LockModule;
using namespace CondModule;namespace BlockQueueModule
{static const int gcap = 10;template<typename T>class BlockQueue{private:bool IsFull(){return _cap==_q.size();}bool IsEmpty(){return _q.empty();}public:BlockQueue(int cap=gcap):_cap(cap){// pthread_mutex_init(&_mutex,nullptr);// pthread_cond_init(&_p_cond,nullptr);// pthread_cond_init(&_c_cond,nullptr);}void Pop(int*data){//pthread_mutex_lock(&_mutex);LockGuard lockguard(_mutex);//1.队列不能为空while(IsEmpty()){_c_nums++;//pthread_cond_wait(&_c_cond,&_mutex);_c_cond.Wait(_mutex);_c_nums--;}*data=_q.front();_q.pop();//if(_p_nums) pthread_cond_signal(&_p_cond);if(_p_nums) _c_cond.Notify();//pthread_mutex_unlock(&_mutex);}void Equeue(const int&data) //生产者{//pthread_mutex_lock(&_mutex);LockGuard lockguard(_mutex);//初始化自动上锁 出作用域解锁//1.放入数据前队列不能为满while(IsFull()){//2.为满就让该线程释放锁 进入等待队列_p_nums++;// 等待生产者线程+1//pthread_cond_wait(&_p_cond,&_mutex);//wait的时候 有锁的话 会导致消费线程申请不到锁 导致一直在等待_p_cond.Wait(_mutex);_p_nums--;//3.等待结束唤醒线程 并申请锁（因为在临界区内，pthread_cond_wait会自动申请锁）}//4.到此时肯定未满 生产者存入数据_q.push(data);//5.此时肯定有数据//if(_c_nums) pthread_cond_signal(&_c_cond); //有等待的消费者线程就唤醒一个if(_c_nums) _p_cond.Notify();//6.唤醒线程要在解锁前还是解锁后？//signal通知线程 线程被唤醒后还要申请到锁才能继续执行//(1)在解锁前唤醒它 它申请不到锁 就会阻塞在申请锁的队列中 直到申请到锁//(2)如果被其它进程申请到了锁 就继续阻塞在申请锁的队列中 //7.如果生产者只生成了1个资源，但broadcast()唤醒了等待队列的所有线程会怎么样？//会发生伪唤醒。第一个申请到锁的线程获取了资源。现在没有资源了，可是第二个申请到锁的线程还是会在临界区内继续执行 //解决方法:if()改为while()判断 在线程被唤醒后，重新检查条件是否满足，并在不满足时重新进入等待状态。//(即重新看是否满足while的判断，满足就重新进入等待队列，不满足退出while循环)//pthread_mutex_unlock(&_mutex);}~BlockQueue(){// pthread_mutex_destroy(&_mutex);// pthread_cond_destroy(&_p_cond);// pthread_cond_destroy(&_c_cond);}private:std::queue<T> _q;//队列int _cap;        //队列数据上限Mutex _mutex; //互斥Cond _p_cond; //生产者条件变量Cond _c_cond; //消费者条件变量int _c_nums=0;  //等待的消费者线程int _p_nums=0;  //等待的生产者线程};
}

对条件变量的封装

#pragma once#include "Mutex.hpp"using namespace LockModule;namespace CondModule
{class Cond{public:Cond(){int n=pthread_cond_init(&_cond,nullptr);(void)n;}void Wait(Mutex&mutex){int n=pthread_cond_wait(&_cond,mutex.LockPtr());(void)n;}void Notify(){int n=pthread_cond_signal(&_cond);(void)n;}void NotifyAll(){int n=pthread_cond_broadcast(&_cond);(void)n;}~Cond(){int n=pthread_cond_destroy(&_cond);(void)n;}private:pthread_cond_t _cond;};
}

对锁的封装

#pragma once
#include <iostream>
#include <pthread.h>namespace LockModule
{class Mutex{public:Mutex(const Mutex&) = delete;const Mutex& operator = (const Mutex&) = delete;Mutex(){int n = ::pthread_mutex_init(&_lock, nullptr);(void)n;}~Mutex(){int n = ::pthread_mutex_destroy(&_lock);(void)n;}void Lock(){int n = ::pthread_mutex_lock(&_lock);(void)n;}pthread_mutex_t *LockPtr(){return &_lock;}void Unlock(){int n = ::pthread_mutex_unlock(&_lock);(void)n;}private:pthread_mutex_t _lock;};class LockGuard{public:LockGuard(Mutex &mtx):_mtx(mtx){_mtx.Lock();}~LockGuard(){_mtx.Unlock();}private:Mutex &_mtx;};
}

上层接口

#include"BlcokQueue.hpp"
#include<pthread.h>
#include<unistd.h>using namespace BlockQueueModule;void* Consumer(void*args)
{BlockQueue<int>*bq=static_cast<BlockQueue<int>*>(args);int data;while (true){sleep(2);//1.从队列中获取数据bq->Pop(&data);//2.处理数据printf("消费者获取数据:%d\n",data);}}void* Productor(void*args)
{BlockQueue<int>*bq=static_cast<BlockQueue<int>*>(args);//1.从外部获取数据int data=10;while(true){//2.把数据输入队列中bq->Equeue(data);printf("生产者存入数据:%d\n",data);data++;}
}
int main()
{BlockQueue<int>* bq=new(BlockQueue<int>);pthread_t c,p;pthread_create(&c,nullptr,Consumer,(void*)bq);pthread_create(&p,nullptr,Productor,(void*)bq);pthread_join(p,nullptr);pthread_join(c,nullptr);delete bq;}

3.生产消费者模型高效在哪里？

生产消费者模型，三种关系生产者和生产者 消费者和消费者 生产者和消费者都是互斥的，在临界区内都是串行的，有一个线程在内，其它线程都不能进来，怎么就高效了呢？

想一想，当其中一个线程在临界区内，其它线程呢？

1.生产者在从外部获取数据，不需要等待消费者处理完数据。消费者在处理数据，不需要等待生产者生成数据。
通过这种方式，生产者和消费者可以并行运行，避免了阻塞和等待，从而提高了资源的利用率。

2.临界区可以当作缓冲区，调节生产与消费的速度。

如果生产者的生产速度快于消费者的消费速度，缓冲区会存储数据，生产者可以继续生产而不会被阻塞。
如果消费者的消费速度快于生产者的生产速度，缓冲区中的数据会被快速消费，生产者有更多的时间来生产新数据。