Linux 线程互斥
在这漫长的暑假，学习让我感到不再孤单，一起为了秋招努力吧！(有一位一起学习的朋友，最近拿到了腾讯的实习，好羡慕~)
目录
进程线程间的互斥相关背景概念
多执行流下没有互斥锁带来的问题
线程不安全的原因
互斥量接口
pthread_mutex_init
pthread_mutex_destroy
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
pthread_mutex_lock
pthread_mutex_unlock
互斥锁&抢票逻辑代码
C++11里面的互斥锁
锁的原理
汇编代码层次理解
补充
静态的互斥锁使用
进程线程间的互斥相关背景概念
临界资源：多线程执行流共享的资源就叫做临界资源
临界区：每个线程内部，访问临界资源的代码，就叫做临界区
互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成
是不是感觉太官方了，我们来看一下稍微通俗的解释(方便将来面试来讲)：
多执行流下没有互斥锁带来的问题
我们先不使用互斥锁，实现一个抢票逻辑看会出现什么问题。
代码测试：
test.cc
#include
#include
#include
using namespace std;
int tickes = 1000;
void* ThreadRun(void* args)
{
int id = *(int*)args;
delete (int*)args;
while(true)
{
if(tickes > 0)
{
//抢票
usleep(1000);
cout << "我是[" << id <<"] 我要抢的票是: " << tickes << endl;
tickes--;
}
else
{
break;
}
}
}
int main()
{
pthread_t tid[5];
for(int i = 0; i < 5; i++)
{
int* id = new int(i);
pthread_create(tid+i, nullptr, ThreadRun, (void*)id);
}
for(int i = 0; i < 5; i++)
{
pthread_join(tid[i], nullptr);
}
return 0;
} Makefile
test:test.cc
g++ -o $@ $^ -lpthread -std=c++11
.PHONY:clean
clean:
rm -f test运行结果：
这时候我们会发现，多个线程在抢票过程中，会抢到负数的情况，这就意味着票卖多了。这种情况是商家不愿意看到的。所以这段代码在多执行流下存在线程安全问题！
线程不安全的原因
实际上ticket--并非原子性的，它实际上要进行计算是要经过多步的，在这期间就有可能被多个线程重入，导致可能出现问题。
如何解决上面的问题呢？对临界区进行加锁！
1、代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
2、如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
3、如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。
要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。
互斥量接口
pthread_mutex_init
pthread_mutex_t* restrict mutex：传入要初始化锁的地址
const pthread_mutexattr_t* restrict attr：我们不用关心，设置成nullptr
pthread_mutex_destroy
pthread_mutex_t* mutex：传入要释放锁的地址
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
定义在全局的或静态的锁，不用再手动初始化和销毁，直接用就可以了。
pthread_mutex_lock
pthread_mutex_t* mutex：传入锁的地址进行上锁
pthread_mutex_unlock
pthread_mutex_t：传入锁的地址，给对应的锁解开
互斥锁&抢票逻辑代码
test.cc
#include
#include
#include
using namespace std;
class Ticket
{
public:
Ticket()
:_tickes(1000)
{
pthread_mutex_init(&_mtx, nullptr);
}
~Ticket()
{
pthread_mutex_destroy(&_mtx);
}
bool GetTicket()
{
bool rets = true;//rets是每个线程私有的
//对临界区进行加锁保护
//执行这部分代码的执行流是互斥的，也是串行的
pthread_mutex_lock(&_mtx);
if(_tickes > 0)
{
//抢票
usleep(1000);
cout << "我是[" << pthread_self() << "] 我要抢的票是: " << _tickes << endl;
_tickes--;
}
else
{
//没有票
printf("票已经抢空了\n");
rets = false;
}
pthread_mutex_unlock(&_mtx);
return rets;
}
private:
int _tickes;
pthread_mutex_t _mtx;
};
void* ThreadRun(void* args)
{
Ticket* t = (Ticket*)args;
while(true)
{
if(!t->GetTicket())
{
break;
}
}
}
int main()
{
Ticket* t = new Ticket;
pthread_t tid[5];
for(int i = 0; i < 5; i++)
{
int* id = new int(i);
pthread_create(tid+i, nullptr, ThreadRun, (void*)t);
}
for(int i = 0; i < 5; i++)
{
pthread_join(tid[i], nullptr);
}
return 0;
} 运行结果(部分)：
这时候我们发现不会出现负数的情况了。
C++11里面的互斥锁
运行结果：
锁的原理
汇编代码层次理解
原子性：一行代码经过编译后，只有一行汇编代码。ticket--经过汇编是有多行代码的，但是互斥量在设计的时候，绝对不是 "--" 设计的，而是使用上面的方法完成原子性的逻辑。
实际上只有互斥还是存在一定的问题，比如一个线程申请锁处理完逻辑释放锁之后，它会再次竞争锁，甚至在其他线程还没唤醒之前又进行申请锁释放锁的逻辑。因为其它在挂起等待的线程被唤醒是有一定代价的，竞争力明显小于刚释放锁的线程，除非它的时间片到了或收到信号，这时候被挂起的线程才有可能竞争到锁。
补充
实际上临界区我们加完锁之后，就不用担心重入的问题了。
静态的互斥锁使用
test.cc
pthread_mutex_t mymtx = PTHREAD_MUTEX_INITIALIZER;
class Ticket
{
public:
bool GetTicket()
{
bool rets = true;//rets是每个线程私有的
//对临界区进行加锁保护
//执行这部分代码的执行流是互斥的，也是串行的
pthread_mutex_lock(&mymtx);
if(_tickes > 0)
{
//抢票
usleep(1000);
cout << "我是[" << pthread_self() << "] 我要抢的票是: " << _tickes << endl;
_tickes--;
}
else
{
//没有票
printf("票已经抢空了\n");
rets = false;
}
pthread_mutex_unlock(&mymtx);
return rets;
}
private:
int _tickes = 1000;
pthread_mutex_t _mtx;
};
void* ThreadRun(void* args)
{
Ticket* t = (Ticket*)args;
while(true)
{
if(!t->GetTicket())
{
break;
}
}
}
int main()
{
Ticket* t = new Ticket;
pthread_t tid[5];
for(int i = 0; i < 5; i++)
{
int* id = new int(i);
pthread_create(tid+i, nullptr, ThreadRun, (void*)t);
}
for(int i = 0; i < 5; i++)
{
pthread_join(tid[i], nullptr);
}
return 0;
}
运行结果：
看到这里，给博主点个赞吧~
