Linux多线程互斥锁使用攻略

本文详细讲解了Linux多线程编程中使用互斥锁解决共享资源访问冲突的技巧。文章以经典的火车票抢购场景为例，阐述了多线程并发访问共享资源（票数）可能导致数据竞争和不一致性问题，进而出现票数为负的情况。文章深入分析了问题产生的原因，并分别介绍了使用全局锁、局部锁和线程数据以及`LockGuard`类进行RAII风格的锁管理等多种解决方案，最终提升了代码的线程安全性和效率，并对锁的背景概念、使用原理、以及如何避免死锁等问题进行了深入探讨，旨在帮助读者掌握Linux多线程互斥锁的高级使用方法。

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

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

多线程抢票问题

假设我们有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;
}</p>

问题分析

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

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

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

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

原因解析

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

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

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

解决方案：使用互斥锁

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

使用全局锁

#include "Thread.hpp"
int tickets = 1000; // 票数
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; // 全局锁<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;
}</p>

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

使用局部锁和线程数据

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

#include "Thread.hpp"
int tickets = 1000; // 票数<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;
}</p>

锁的背景概念

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

锁的使用和原理

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

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

锁的封装

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

#pragma once<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;
};</p>

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

#include "Thread.hpp"<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;
}</p>

线程安全与可重入

• 线程安全：多线程并发执行同一段代码时，结果一致。
• 可重入：函数在被不同执行流调用时，结果不受影响。

死锁

死锁是指多个线程因互相等待对方释放资源而陷入永久等待的状态。死锁的四个必要条件是：

1. 互斥：资源只能被一个线程占用。
2. 持有并等待：一个线程在持有资源的同时等待其他资源。
3. 不可剥夺：资源不能被强制从一个线程转移到另一个线程。
4. 循环等待：存在一个线程等待链，形成循环。

避免死锁的策略包括：

• 避免同时申请多个锁。
• 使用锁的申请顺序。
• 避免长时间持有锁。

总之，多线程编程中的互斥问题可以通过使用锁来解决，但需要注意锁的使用可能会导致性能下降和死锁问题。

以上就是《Linux多线程互斥锁使用攻略》的详细内容，更多关于多线程编程,互斥锁,线程安全,死锁,共享资源的资料请关注golang学习网公众号！