Linux——多线程互斥-linux运维-PHP中文网

Linux——多线程互斥

蓮花仙者

发布： 2025-04-18 13:56:17

原创

266人浏览过

多线程互斥抢票问题及其解决方案

在多线程编程中，处理共享资源时可能会遇到互斥问题。让我们深入探讨一下这个问题，并通过一个具体的抢票场景来理解和解决它。

多线程抢票问题

假设我们有1000张火车票，四个线程同时在抢票。代码如下：

#include "Thread.hpp"
int tickets = 1000; // 票数
<p>void<em> thread_run(void</em> args) {
string name = static_cast<const char*>(args);
while(true) {
if(tickets > 0) {
usleep(1234); // 1秒=1000毫秒=1000000微秒
cout << name << "抢到票, 票数为: " << tickets-- << endl;
} else {
break;
}
}
return nullptr;
}</p><p>int main() {
unique_ptr<Thread> thread1(new Thread(thread_run, (void<em>)"user1",1));
unique_ptr<Thread> thread2(new Thread(thread_run, (void</em>)"user2",2));
unique_ptr<Thread> thread3(new Thread(thread_run, (void<em>)"user3",3));
unique_ptr<Thread> thread4(new Thread(thread_run, (void</em>)"user4",4));
thread1->join();
thread2->join();
thread3->join();
thread4->join();
return 0;
}

登录后复制

Linux——多线程互斥

问题分析

运行上述代码时，可能会看到票数出现0、-1、-2等负数的情况。这是由于多线程并发访问共享资源（票数）时，导致的数据竞争和不一致性。

多线程交叉执行的本质是调度器频繁切换线程。线程切换可能在以下几种情况发生：

时间片用完
更高优先级线程就绪
线程进入等待状态

线程在从内核态切换到用户态时，会检测调度状态并可能进行线程切换。

原因解析

在读取和修改共享变量ticket的过程中，由于线程切换，可能会发生以下情况：

读取到寄存器：线程1读取票数到CPU寄存器中。
判断和修改：如果在判断和修改之间发生线程切换，其他线程也可能读取到同样的票数，导致多个线程同时减少票数。

例如，假设四个线程同时读取到票数为1，然后线程1将票数减少到0并打印，之后其他线程也尝试减少票数，导致票数变成负数。

解决方案：使用互斥锁

为了解决上述问题，我们可以使用互斥锁来确保在修改共享资源时，只有单个线程能够访问。

使用全局锁

#include "Thread.hpp"
int tickets = 1000; // 票数
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; // 全局锁</p><p>void<em> thread_run(void</em> args) {
string name = static_cast<const char*>(args);
while(true) {
pthread_mutex_lock(&lock); // 加锁
if(tickets > 0) {
usleep(1234); // 1秒=1000毫秒=1000000微秒
cout << name << "抢到票, 票数为: " << tickets-- << endl;
} else {
pthread_mutex_unlock(&lock);
break;
}
pthread_mutex_unlock(&lock); // 解锁
}
return nullptr;
}</p><p>int main() {
unique_ptr<Thread> thread1(new Thread(thread_run, (void<em>)"user1",1));
unique_ptr<Thread> thread2(new Thread(thread_run, (void</em>)"user2",2));
unique_ptr<Thread> thread3(new Thread(thread_run, (void<em>)"user3",3));
unique_ptr<Thread> thread4(new Thread(thread_run, (void</em>)"user4",4));
thread1->join();
thread2->join();
thread3->join();
thread4->join();
return 0;
}

登录后复制

Linux——多线程互斥

使用全局锁后，线程在进入临界区时会加锁，离开时解锁，确保了票数的正确性。然而，由于线程串行执行，速度可能会变慢。

使用局部锁和线程数据

为了进一步优化，我们可以使用局部锁和线程数据来管理每个线程的抢票过程：

#include "Thread.hpp"
int tickets = 1000; // 票数</p><p>class ThreadData {
public:
ThreadData(const string& threadname, pthread_mutex_t <em>mutex_p) : _threadname(threadname), _mutex_p(mutex_p) {}
~ThreadData() {}
public:
string _threadname;
pthread_mutex_t </em>_mutex_p;
};</p><p>void<em> thread_run(void</em> args) {
ThreadData<em> p = static_cast<ThreadData</em>>(args);
while(true) {
pthread_mutex_lock(p->_mutex_p); // 加锁
if(tickets > 0) {
usleep(1234); // 1秒=1000毫秒=1000000微秒
cout << p->_threadname << "抢到票, 票数为: " << tickets-- << endl;
} else {
pthread_mutex_unlock(p->_mutex_p);
break;
}
pthread_mutex_unlock(p->_mutex_p); // 解锁
usleep(1234); // 模拟抢完票形成一个订单
}
return nullptr;
}</p><p>int main() {
pthread_mutex_t lock;
pthread_mutex_init(&lock, nullptr); // 初始化锁
vector<pthread_t> arr(4);
for(int i = 0; i < 4; i++) {
string thread_name = "user" + to_string(i + 1);
ThreadData* data = new ThreadData(thread_name, &lock);
pthread_create(&arr[i], nullptr, thread_run, data);
}
for(int i = 0; i < 4; i++) {
pthread_join(arr[i], nullptr);
}
return 0;
}

登录后复制

Linux——多线程互斥

锁的背景概念

临界资源：多线程共享的资源。
临界区：访问临界资源的代码段。
互斥：确保同一时间只有一个线程访问临界资源。
原子性：操作要么完成，要么不完成，不会被打断。

锁的使用和原理

锁本身是共享资源，用于保护其他共享资源。pthread_mutex_lock和pthread_mutex_unlock是原子操作，确保锁的安全性。

加锁和解锁的原理基于交换指令（如swap或exchange），确保原子性。

锁的封装

为了兼容C++，我们可以封装锁的接口：

#pragma once</p><h1>include <iostream></h1><h1>include <pthread.h></h1><h1>include <cassert></h1><h1>include <string></h1><h1>include <cstring></h1><h1>include <vector></h1><h1>include <unistd.h></h1><h1>include <cstdlib></h1><h1>include <memory></h1><p>using namespace std;</p><p>class Mutex {
public:
Mutex(pthread_mutex_t <em>lock_p = nullptr) : _lock_p(lock_p) {}
void lock() { if(_lock_p) pthread_mutex_lock(_lock_p); }
void unlock() { if(_lock_p) pthread_mutex_unlock(_lock_p); }
~Mutex() {}
private:
pthread_mutex_t </em>_lock_p;
};</p><p>class LockGuard {
public:
LockGuard(pthread_mutex_t *mutex) : _mutex(mutex) { _mutex.lock(); }
~LockGuard() { _mutex.unlock(); }
private:
Mutex _mutex;
};

登录后复制

使用LockGuard可以实现RAII风格的自动加锁和解锁：

#include "Thread.hpp"</p><h1>include "Mutex.hpp"</h1><p>int tickets = 1000; // 票数</p><p>class ThreadData {
public:
ThreadData(const string& threadname, pthread_mutex_t <em>mutex_p) : _threadname(threadname), _mutex_p(mutex_p) {}
~ThreadData() {}
public:
string _threadname;
pthread_mutex_t </em>_mutex_p;
};</p><p>void<em> thread_run(void</em> args) {
ThreadData<em> p = static_cast<ThreadData</em>>(args);
LockGuard lockGuard(p->_mutex_p); // 自动加锁解锁
while(true) {
if(tickets > 0) {
usleep(1234); // 1秒=1000毫秒=1000000微秒
cout << p->_threadname << "抢到票, 票数为: " << tickets-- << endl;
} else {
break;
}
}
return nullptr;
}</p><p>int main() {
pthread_mutex_t lock;
pthread_mutex_init(&lock, nullptr); // 初始化锁
vector<pthread_t> arr(4);
for(int i = 0; i < 4; i++) {
string thread_name = "user" + to_string(i + 1);
ThreadData* data = new ThreadData(thread_name, &lock);
pthread_create(&arr[i], nullptr, thread_run, data);
}
for(int i = 0; i < 4; i++) {
pthread_join(arr[i], nullptr);
}
return 0;
}

登录后复制

Linux——多线程互斥