当前位置：首页 > news >正文

线程互斥与同步

news 2025/8/7 6:56:31

线程互斥

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

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

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

保护作⽤

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

互斥量mutex

• ⼤部分情况，线程使⽤的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量

归属单个线程，其他线程⽆法获得这种变量。

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

成线程之间的交互。

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

示例代码：

#include <iostream>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
using namespace std;int ticket = 100;
void *route(void *args)
{char *id = (char *)args;while (true){if (ticket > 0){sleep(1);cout << id << "sells ticket:" <<ticket<< endl;ticket--;}else{break;}}return nullptr;
}
int main()
{pthread_t t1, t2, t3, t4;pthread_create(&t1, nullptr, route, (void *)"thread 1");pthread_create(&t2, nullptr, route, (void *)"thread 2");pthread_create(&t3, nullptr, route, (void *)"thread 3");pthread_create(&t4, nullptr, route, (void *)"thread 4");pthread_join(t1, NULL);pthread_join(t2, NULL);pthread_join(t3, NULL);pthread_join(t4, NULL);return 0;
}

结果：

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

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

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

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

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

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

进⼊该临界区。

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

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

互斥量的接口

初始化互斥量

静态分配

动态分配

参数：

mutex：要初始化的互斥量

attr：NULL
销毁互斥量

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

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

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

互斥量加锁和解锁

返回值:成功返回0,失败返回错误号
调用pthread_ lock 时，可能会遇到以下情况:

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

• 发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到

互斥量，那么pthread_ lock调用会陷⼊阻塞(执⾏流被挂起)，等待互斥量解锁。

代码：

#include <iostream>
#include <cstring>
#include <pthread.h>
#include <unistd.h>
using namespace std;int ticket = 100;
pthread_mutex_t mutex;
void *route(void *args)
{char *id = (char *)args;while (true){ pthread_mutex_lock(&mutex);if (ticket > 0){sleep(1);cout << id << "sells ticket:" <<ticket<< endl;ticket--;pthread_mutex_unlock(&mutex);}else{    pthread_mutex_unlock(&mutex);break;}}return nullptr;
}
int main()
{pthread_mutex_init(&mutex,nullptr);pthread_t t1, t2, t3, t4;pthread_create(&t1, nullptr, route, (void *)"thread 1");pthread_create(&t2, nullptr, route, (void *)"thread 2");pthread_create(&t3, nullptr, route, (void *)"thread 3");pthread_create(&t4, nullptr, route, (void *)"thread 4");pthread_join(t1, NULL);pthread_join(t2, NULL);pthread_join(t3, NULL);pthread_join(t4, NULL);pthread_mutex_destroy(&mutex);return 0;
}

结果：

互斥量实现原理探究

为了实现互斥锁操作,⼤多数体系结构都提供了swap或exchange指令,该指令的作⽤是把寄存器和

内存单元的数据相交换,由于只有⼀条指令,保证了原⼦性,即使是多处理器平台,访问内存的总线周

期也有先后,⼀个处理器上的交换指令执⾏时另⼀个处理器的交换指令只能等待总线周期。

互斥量的封装

#include<iostream>
#include<cstring>
#include<pthread.h>
using namespace std;namespace LockMoudle{class Mutex{public: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;}
~Mutex(){}private:pthread_mutex_t _mutex;};class LockGuard{public :LockGuard(Mutex &mutex):_mutex(mutex){_mutex.Lock();}~LockGuard(){_mutex.Unlock();}private:Mutex &_mutex;};
}

线程同步

同步概念与竞态条件
同步：在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，从⽽有效避免

饥饿问题，叫做同步

• 竞态条件：因为时序问题，⽽导致程序异常，我们称之为竞态条件。

条件变量函数

初始化

参数：

cond：要初始化的条件变

attr：NULL

销毁

等待条件满足

参数：

cond：要在这个条件变量上等待

mutex：互斥量

唤醒等待

代码：

#include <iostream>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
using namespace std;pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;void *active(void *arg){
string name=static_cast<const char*>(arg);
while(true){pthread_mutex_lock(&mutex);pthread_cond_wait(&cond,&mutex);cout<<name<<"活动"<<endl;pthread_mutex_unlock(&mutex);
}
}
int main(){pthread_t t1,t2;pthread_create(&t1,nullptr,active,(void*)"thread-1");pthread_create(&t2,nullptr,active,(void*)"thread-2");while(true){// pthread_cond_signal(&cond);//唤醒一个线程pthread_cond_broadcast(&cond);//唤醒所有线程sleep(1);}
pthread_join(t1,nullptr);
pthread_join(t2,nullptr);
}

生产者消费者模型

生产者消费者模式就是通过⼀个容器来解决生产者和消费者的强耦合问题。⽣产者和消费者彼此之间不直接通讯，而通过阻塞队列来进⾏通讯，所以生产者生产完数据之后不⽤等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于⼀个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给⽣产者和消费者解耦的
生产者消费者模型优点
解耦

⽀持并发

⽀持忙闲不均

基于BlockingQueue的⽣产者消费者模型

在多线程编程中阻塞队列(Blocking Queue)是⼀种常⽤于实现⽣产者和消费者模型的数据结构。其与普通的队列区别在于，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放⼊了元素；当队列满时，往队列⾥存放元素的操作也会被阻塞，直到有元素被从队列中取出(以上的操作都是基于不同的线程来说的，线程在对阻塞队列进程操作时会被阻塞)

代码：

#ifndef __BLOCK_QUEUE_HPP__
#define __BLOCK_QUEUE_HPP__#include <iostream>
#include <cstring>
#include <queue>
#include <pthread.h>
using namespace std;template <typename T>
class BlockQueue
{
private:bool isFull() const{return _block_queue.size() == _cap;}bool isEmpty() const{return _block_queue.empty();}public:BlockQueue(int cap) : _cap(cap){_productor_wait_num = 0;_consumer_wait_num = 0;pthread_mutex_init(&_mutex, nullptr);pthread_cond_init(&_product_cond, nullptr);pthread_cond_init(&_consum_cond, nullptr);}// 入队操作，返回void，参数使用const引用void Enqueue(const T &in){pthread_mutex_lock(&_mutex);while (isFull()){_productor_wait_num++;pthread_cond_wait(&_product_cond, &_mutex);_productor_wait_num--;}_block_queue.push(in);// 唤醒等待的消费者if (_consumer_wait_num > 0){pthread_cond_signal(&_consum_cond);}pthread_mutex_unlock(&_mutex);  // 确保解锁}// 出队操作，返回取出的元素T Pop(){pthread_mutex_lock(&_mutex);while (isEmpty()){_consumer_wait_num++;pthread_cond_wait(&_consum_cond, &_mutex);_consumer_wait_num--;}T data = _block_queue.front();  // 获取队首元素_block_queue.pop();             // 移除队首元素// 唤醒等待的生产者if (_productor_wait_num > 0){pthread_cond_signal(&_product_cond);}pthread_mutex_unlock(&_mutex);return data;  // 返回取出的元素}// 获取当前队列大小size_t size() const{pthread_mutex_lock(&_mutex);size_t s = _block_queue.size();pthread_mutex_unlock(&_mutex);return s;}~BlockQueue(){pthread_mutex_destroy(&_mutex);pthread_cond_destroy(&_product_cond);pthread_cond_destroy(&_consum_cond);}private:queue<T> _block_queue;      // 阻塞队列int _cap;                   // 队列容量pthread_mutex_t _mutex;     // 互斥锁pthread_cond_t _product_cond;  // 生产者条件变量pthread_cond_t _consum_cond;   // 消费者条件变量int _productor_wait_num;    // 等待的生产者数量int _consumer_wait_num;     // 等待的消费者数量
};#endif

为什么 pthread_cond_wait 需要互斥量?

• 条件等待是线程间同步的⼀种⼿段，如果只有⼀个线程，条件不满⾜，⼀直等下去都不会满⾜，

所以必须要有⼀个线程通过某些操作，改变共享变量，使原先不满⾜的条件变得满⾜，并且友好

的通知等待在条件变量上的线程。

• 条件不会⽆缘⽆故的突然变得满⾜了，必然会牵扯到共享数据的变化。所以⼀定要⽤互斥锁来保

护。没有互斥锁就⽆法安全的获取和修改共享数据。