【Linux操作系统】多线程抢票逻辑——学习互斥量(锁)函数接口


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>

– 操作并不是原子操作,而是对应三条汇编指令:

  1. load :将共享变量ticket从内存加载到寄存器中
  2. update : 更新寄存器里面的值,执行-1操作
  3. store :将新值,从寄存器写回共享变量ticket的内存地址

要解决以上问题,需要做到三点:

  1. 代码必须要有互斥行为:当代码进入临界区执行时,不允许其他线程进入该临界区。
  2. 如果线程不在临界区中执行,那么该线程不能阻止其他线程进入临界区。
  3. 如果多个线程同时要求执行临界区的代码,并且临界区没有线程在执行,那么只能允许一个线程进入该临界区。

要做到这三点,本质上就是需要一把。Linux上提供的这把锁叫互斥量
在这里插入图片描述

3.互斥量(锁)的函数接口

3.1初始化互斥量

初始化互斥量有两种方法:

  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张票还再强的问题了。
在这里插入图片描述
细节:

  1. 凡是访问同一个临界资源的线程,都要进行加锁保护,必须加同一把锁。
  2. 每一个线程访问临界区之前,得加锁,加锁的本质是给临界区加锁。加锁的粒度要细一些,避免影响串行时间变长。
  3. 临界区可以是一行代码,一批代码。
  4. 线程访问临界区的时候,需要先加锁,访问同一个临界资源的线程必须先要看到同一把锁,所以锁本身就是公共资源,那么锁如何保证自己的安全呢?——加锁和解锁本身就是原子的。
  5. a.加锁后线程可能被切换吗?当然可能,不要特殊化加锁和解锁,还有临界区代码。
  6. b.切换会有影响吗?不会,因为在这个线程被切走的期间,任何线程都没有办法进入临界区,因为它无法申请到锁!”在这个切走的这个期间锁被“我拿走了“,只有等”我“回来并且将这个临界资源访问完了,并解锁了,其它线程才能才能访问这块临界资源。这也正是体现互斥带来的串行化表现,站在其它线程的角度,对其它线程有意义的状态就是:锁被我申请(持有锁),锁被我释放了(不持有锁),原子性也就体现在这里。
  • 6
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_麦子熟了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值