多线程互斥抢票问题及其解决方案
在多线程编程中，处理共享资源时可能会遇到互斥问题。让我们深入探讨一下这个问题，并通过一个具体的抢票场景来理解和解决它。
多线程抢票问题
假设我们有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;
}
问题分析
运行上述代码时，可能会看到票数出现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;
}
使用全局锁后，线程在进入临界区时会加锁，离开时解锁，确保了票数的正确性。然而，由于线程串行执行，速度可能会变慢。
使用局部锁和线程数据
为了进一步优化，我们可以使用局部锁和线程数据来管理每个线程的抢票过程：
#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;
}
锁的背景概念
- 临界资源：多线程共享的资源。
- 临界区：访问临界资源的代码段。
- 互斥：确保同一时间只有一个线程访问临界资源。
- 原子性：操作要么完成，要么不完成，不会被打断。
锁的使用和原理
锁本身是共享资源，用于保护其他共享资源。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;
}
线程安全与可重入
- 线程安全：多线程并发执行同一段代码时，结果一致。
- 可重入：函数在被不同执行流调用时，结果不受影响。
死锁
死锁是指多个线程因互相等待对方释放资源而陷入永久等待的状态。死锁的四个必要条件是：
- 互斥：资源只能被一个线程占用。
- 持有并等待：一个线程在持有资源的同时等待其他资源。
- 不可剥夺：资源不能被强制从一个线程转移到另一个线程。
- 循环等待：存在一个线程等待链，形成循环。
避免死锁的策略包括：
- 避免同时申请多个锁。
- 使用锁的申请顺序。
- 避免长时间持有锁。
总之，多线程编程中的互斥问题可以通过使用锁来解决，但需要注意锁的使用可能会导致性能下降和死锁问题。
