文章目录
- 1.进程线程间的互斥相关背景概念
- 2.联系代码学习同步互斥问题
- 3.互斥量（锁）的函数接口
- 3.1初始化互斥量
- 3.2销毁互斥量
- 3.3互斥量加锁和解锁
- 3.4改进多线程抢票代码
1.进程线程间的互斥相关背景概念
- 临界资源：多线程执行流共享的资源就叫做临界资源。
- 临界区：每个线程内部，访问临界资源的代码，就叫做临界区。
- 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用。
- 原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。
- 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
- 但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。
- 多个线程并发的操作共享变量，会带来一些问题。
2.联系代码学习同步互斥问题
下面我们通过实现一个简单的多线程抢票逻辑，来学习一下有关多线程的知识以及一些重要事项。
// 操作共享变量会有问题的售票系统代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
int ticket = 100;
void *route(void *arg)
{
char *id = (char*)arg;
while ( 1 )
{
if ( ticket > 0 )
{
usleep(1000);
printf("%s sells ticket:%d\n", id, ticket);
ticket--;
}
else
{
break;
}
}
}
int main( void )
{
pthread_t t1, t2, t3, t4;
pthread_create(&t1, NULL, route, "thread 1");
pthread_create(&t2, NULL, route, "thread 2");
pthread_create(&t3, NULL, route, "thread 3");
pthread_create(&t4, NULL, route, "thread 4");
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_join(t3, NULL);
pthread_join(t4, NULL);
return 0;
}
执行结果：
一次执行结果：
thread 4 sells ticket:100
...
thread 4 sells ticket:1
thread 2 sells ticket:0
thread 1 sells ticket:-1
thread 3 sells ticket:-2
从运行结果可以看出，这个抢票逻辑是有问题的，因为票数为0了还在竞争墙皮安排，那么为什么可能无法获得正确的争取结果呢？
- if 语句判断条件为真以后，代码可以并发的切换到其他线程，代码中的休眠给了其它线程竞争的时间。
- usleep 这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段。
- –ticket 操作本身就不是一个原子操作
取出ticket--部分的汇编代码
objdump -d a.out > test.objdump
152 40064b: 8b 05 e3 04 20 00 mov 0x2004e3(%rip),%eax # 600b34 <ticket>
153 400651: 83 e8 01 sub $0x1,%eax
154 400654: 89 05 da 04 20 00 mov %eax,0x2004da(%rip) # 600b34 <ticket>
– 操作并不是原子操作，而是对应三条汇编指令：
- load ：将共享变量ticket从内存加载到寄存器中
- update : 更新寄存器里面的值，执行-1操作
- store ：将新值，从寄存器写回共享变量ticket的内存地址
要解决以上问题，需要做到三点：
- 代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入该临界区。
- 如果线程不在临界区中执行，那么该线程不能阻止其他线程进入临界区。
- 如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区。
要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。
3.互斥量（锁）的函数接口
3.1初始化互斥量
初始化互斥量有两种方法：
- 方法1，静态分配:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
2.方法2，动态分配:
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t
*restrict attr);
参数：
mutex：要初始化的互斥量
attr：NULL
3.2销毁互斥量
销毁互斥量需要注意：
- 使用PTHREAD_MUTEX_INITIALIZER初始化的互斥量不需要销毁。
- 不要销毁一个已经加锁，会未解锁的互斥量。
- 已经销毁的互斥量，要确保后面不会有线程再尝试加锁。
int pthread_mutex_destroy(pthread_mutex_t *mutex)；
3.3互斥量加锁和解锁
int pthread_mutex_lock(pthread_mutex_t *mutex);//加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁
返回值:成功返回0,失败返回错误号
调用 pthread_ lock 时，可能会遇到以下情况：
- 互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功。
- 发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_ lock调用会陷入阻塞(执行流被挂起)，等待互斥量解锁。
3.4改进多线程抢票代码
关于锁（互斥量）的函数接口学完之后，我们来一起改进上面的多线程抢票代码：
#include<iostream>
#include<string>
#include<unistd.h>
#include<pthread.h>
using namespace std;
//临界资源
int tickets = 1000;//全局变量，共享对象
//如果将锁定义成全局，则可以采用宏函数的方式对锁进行初始化
//pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
class TData
{
public:
TData(const string& name,pthread_mutex_t* mutex)
:_name(name)
,_pmutex(mutex)
{}
~TData()
{}
public:
string _name;//线程名称
pthread_mutex_t* _pmutex;//锁指针
};
void* threadRoutine(void* args)
{
TData* td = static_cast<TData*>(args);
while(true)
{
//对临界区进行加锁
pthread_mutex_lock(td->_pmutex);
if(tickets > 0)
{
//在睡眠的这2000us期间，就会导致多线程争先访问临界区
usleep(2000);
cout << td->_name << "get a ticket: " << tickets-- << endl;//临界区
pthread_mutex_unlock(td->_pmutex);
}
else
{
pthread_mutex_unlock(td->_pmutex);
break;
}
//抢完一张票之后，还有后序动作
//usleep(13);
}
return nullptr;
}
int main()
{
pthread_mutex_t mutex;//定义锁
pthread_mutex_init(&mutex,nullptr);//初始化锁
pthread_t tids[4];
int n = sizeof(tids)/sizeof(tids[0]);
for(int i=0;i<n;i++)
{
char name[64];
snprintf(name,64,"thread-%d",i+1);
TData* td = new TData(name,&mutex);
//创建线程
pthread_create(tids+i,nullptr,threadRoutine,td);
}
for(int i=0;i<n;i++)
{
//等待线程
pthread_join(tids[i],nullptr);
}
//销毁锁
pthread_mutex_destroy(&mutex);
return 0;
}
makefile文件：
threadTest:mythread.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
rm -f threadTest
运行结果：现在的结果就没有出现数据不一致，抢到只剩0张票还再强的问题了。
细节：
- 凡是访问同一个临界资源的线程，都要进行加锁保护，必须加同一把锁。
- 每一个线程访问临界区之前，得加锁，加锁的本质是给临界区加锁。加锁的粒度要细一些,避免影响串行时间变长。
- 临界区可以是一行代码，一批代码。
- a.加锁后线程可能被切换吗？当然可能，不要特殊化加锁和解锁，还有临界区代码。
- b.切换会有影响吗？不会，因为在这个线程被切走的期间，任何线程都没有办法进入临界区，因为它无法申请到锁!”在这个切走的这个期间锁被“我拿走了“，只有等”我“回来并且将这个临界资源访问完了，并解锁了，其它线程才能才能访问这块临界资源。这也正是体现互斥带来的串行化表现，站在其它线程的角度，对其它线程有意义的状态就是：锁被我申请(持有锁)，锁被我释放了(不持有锁)，原子性也就体现在这里。
