Linux系统编程6(线程互斥,锁,同步,生产消费模型)

上篇文章介绍完线程的概念后,我们将在这篇文章中初步探讨线程编程以及线程应用中的问题,这篇文章将以抢票系统为例,贯穿整篇文章。笔者将介绍在多线程编程中会出现的问题,什么是同步?什么是互斥?为什么多线程编程常有加锁的概念,什么又是生产者和消费者模型,读完这篇文章,你会得到相应的答案,笔者这里强烈建议各位把文中给出的demo示例自己实现一遍

多线程这部分必须要理论和实操相结合,并不像前面虚拟地址空间,页表这些理论性的知识,只要理解就可以了

目录

初步应用多线程 

互斥 

锁 

深入理解锁

封装锁

死锁 

避免死锁的方法 

线程同步 

生产者与消费者模型 

条件变量 

条件变量的相应接口 

条件变量代码实操 

理解条件变量 

基于BlockingQueue的生产者消费者模型

生产者消费者模型的意义


 

初步应用多线程 

多线程是一朵带刺的玫瑰,在享受它带来方便的同时要煞费思量多线程带来的问题

接下来咱们以一个实例来刨析使用线程究竟会带来哪些问题,咱们模拟一个抢票的场景,在main函数里创建一个次线程,然后主线程和次线程同时进行抢票,代码如下

#include
#include
#include

int counter = 100;

void* start_routine(void* args)
{   
    while(counter > 0){
        counter--;
        std::cout << "抢票用户:次线程,剩余票数: " << counter << std::endl;
    }

    return nullptr;
}


int main()
{   
   pthread_t thread;
   pthread_create(&thread, NULL, start_routine, NULL);
    
    while ( counter > 0){
        counter--;
        std::cout << "抢票用户:主线程, 剩余票数:" << counter << std::endl;
    }

    pthread_join(thread, NULL);

    return 0;
}

代码很简单,看运行结果

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第1张图片

可以发现,所有的票都是主线程抢到的,次线程一张票都没有抢到,这是因为次线程还没有创建完的时候,CPU不断执行主线程的循环,把票抢完了

我们要模拟出多个线程间交叉执行的情况,而不是某一个线程把所有的票都抢完了,想要模拟出这个场景,我们就得人为让CPU频繁的调度

所以,我们需要在抢票循环之前加上sleep,当某个线程准备开抢时,先休眠一会,被OS挂起,给其他线程启动的机会。但是我们不敢直接用sleep,因为该函数是以秒为单位的,以CPU的速度,如果休眠1秒,会在这个时间间隙内被其中一个线程全部抢完,所以我们要使用另一个函数——usleep

该函数和sleep一样,不过是以微妙为单位,我们调整参数到毫秒级别,这样两个线程就能够交叉抢票了,如下是修改后的代码

#include
#include
#include

int counter = 100;

void* start_routine(void* args)
{     
    while(true){      
        if (counter > 0){          
            counter--;
            usleep(1234);
            std::cout << "抢票用户:"<< (char*) args << " 剩余票数: " << counter << std::endl;                 
        }
        else break;
    }
    
    return nullptr;
}


int main()
{   
   pthread_t thread;
   char second_thread[] = "次线程";
   char main_thread[] = "主线程";
   pthread_create(&thread, NULL, start_routine, (void*)second_thread);
    
   start_routine((void*)main_thread);

   pthread_join(thread, NULL);

   return 0;
}

如下图是运行结果 

 Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第2张图片

根据图上信息,可以发现,两个线程确实实现了交叉抢票,但是吧,最后剩余票数出现了-1是什么情况,两个线程正常抢票,都是进行counter > 0才能进入抢票,可为什么就出现了负数了呢?接下来刨析这个问题(再次建议读者完成代码编写,亲自感受这个过程)

互斥 

当票数counter只剩1的时候,此时次线程从内存中读取数据,发现counter为1,然后判断counter>0为真,但是一进入循环内,就遇到了usleep,于是次线程会被OS挂起,然后OS唤醒主线程,主线程去内存中加载counter数据时,发现counter的值仍为1,就通过了判断语句,同样的它将遇到usleep,被挂起。之后OS唤醒次线程,次线程开始执行counter-1,然后循环,判断counter为0,就退出了循环,接着主线程被OS唤醒,开始执行counter-1,注意此时的counter已经为0了,减去1之后就是-1,这也是为什么最后主线程的剩余票数会变为-1的原因

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第3张图片

可以发现,造成这个问题的根本原因就是因为抢票过程不具备原子性,什么是原子性?当一件事具备了原子性,就说明这件事要么做成,要么失败,没有中间状态可言。回顾一下刚才抢票时,次线程检测到counter为1,它进入了循环,如果它具备原子性,那么对于抢票这件事,要么它抢票成功,counter减为0,要么它抢票失败,counter仍为1,轮到主线程抢票,在其它线程眼里这个过程是一瞬间,没任何中间过程的

但事实是它是有中间状态的,它不可能在物理上的一瞬间就抢到票把counter减为0,它是要逐步执行代码的,执行代码是需要时间的,就单单counter--这个操作,就至少得翻译成三条汇编语句逐条执行,在这段时间内,counter的值仍为1,其它线程就有机会进来了

除了上面出现负票这种情况,还有可能会导致票越抢越多的情况,只不过这种情况很难模拟出来,但它确实存在,故此我们理论上分析出现这种情况的原因

假设现在有100张票,有A,B两个进程一起抢票

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第4张图片

这看似一个简单的counter-1操作,背后的CPU至少要分成这三部分完成,上面就是正常抢票过程中,CPU所执行的操作

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第5张图片

如上图,因为A被挂起,长时间处于中间状态,B在这段时间内将票抢空,而A被唤醒后,继续执行中断前的操作,导致了票明明被B抢空了,却又变回99这种越抢越多的情况 

面对类似抢票这种场景就得保证多个线程在执行任务时要是原子的,互斥是保证原子性的手段之一,正在抢的那个线程要么抢成功,要么抢失败,而在它抢的过程中,固有的中间状态靠互斥性来解决,也就是其他线程与当前正抢票的线程保持互斥,不能打扰它抢票

如何做到互斥?解决方法就是加锁

锁 

什么是锁呢?前面提到过,抢票时我们需要对票这种共享资源进行保护,也就是抢票这个事件是要原子的,但是就单单counter--这种操作,得有三条汇编指令才能实现,这就产生了中间状态,锁就是来锁住这个中间状态,大致流程如下

当线程A正在抢票时,它需要申请一把锁,只要它申请锁成功,那么它就可以放心去执行它的抢票代码,其它的线程要想抢票也得先申请锁,但是锁已经被A拿走了,它们只能阻塞等待A释放锁才能够申请到锁

上述过程中,锁将线程A抢票的中间状态锁住了,就能够实现抢票的原子性,在其它线程看来,A抢票就是原子的,就是一瞬间,没有中间过程的。因为A拿到锁正抢票时,其它线程到了就得阻塞等待从而被OS挂起,当它们被唤醒的时候,说明A已抢完票,释放了锁,在它们眼里这可不就是一瞬间的事嘛

明白锁的作用,接下来看看怎么使用锁,锁本质也是一种数据类型,其类型为:pthread_mutex_t,使用锁之前得先申请一个锁

申请一个锁:pthread_mutex_t  mutex;

申请完锁需要对其进行初始化,使用初始化接口:

pthread_mutex_init( pthread_mutex_t  *mutex );

第二种初始化方法:pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

初始化完成之后,就可以使用锁了,使用锁分为加锁和解锁

加锁的接口为:pthread_mutex_lock( pthread_mutex_t *mutex);

解锁的接口为:pthread_mutex_unlock( pthread_mutex_t *mutex);

还有一个加锁的接口为:pthread_mutex_trylock( pthread_mutex_t *mutex);

那这两个加锁接口有什么区别呢?举个例子

有线程A,B共同使用一把锁,当使用pthread_mutex_lock加锁时,A加锁完,B再来就得阻塞等待。而使用pthread_mutex_trylock加锁时,A加锁完,B再来并不会阻塞等待,而是报错返回,因此pthread_mutex_trylock也被称为非阻塞式加锁

那在哪里使用锁呢?在main函数开头就加锁,return前解锁吗?当然不是,我们要明白加锁锁的是一种中间状态,把抢票这个具有过程性的操作给保障成原子性。原本有A,B两个线程同时并行执行,但在对公共资源进行争夺时,就会带来很多的麻烦,采用加锁相当于把这些线程在抢夺资源时排好队,谁先来的谁开始,后面的排队等待,变成一种串行的执行方式

串行排队等待,程序的效率必然会下降,因此在满足公共资源保护的前提下,加锁的范围要尽量的小,接下来通过demo来演示加锁的用法,还是用上面的抢票程序

#include
#include
#include
#include

int counter = 10;

//创建一个全局锁
pthread_mutex_t mutex;

void* start_routine(void* args)
{     
    while(true){

        //在这里加锁,保护公共资源counter
        pthread_mutex_lock(&mutex);
        if (counter > 0){          
            counter--;
            std::cout << "抢票用户:"<< (char*) args << " 剩余票数: " << counter << std::endl;
            //这里counter--已经执行完毕,公共资源保护完成,可以解锁
            pthread_mutex_unlock(&mutex);
            usleep(1234);                             
        }
        else{
            //这里是程序拿到锁,然而没票了,退出之前要解锁
            pthread_mutex_unlock(&mutex);
            break;
        }   
    }

    
    return nullptr;
}


int main()
{   
   pthread_t thread;
   char second_thread[] = "次线程";
   char main_thread[] = "主线程";

   //初始化该全局锁
   pthread_mutex_init(&mutex, NULL);

   pthread_create(&thread, NULL, start_routine, (void*)second_thread);
    
   start_routine((void*)main_thread);

    pthread_join(thread, NULL);

    return 0;
}

由上面的demo可以看出,加锁和解锁的范围还是很短的,运行上面的demo,你会发现程序抢票的过程明显变慢,这是因为线程在抢票时是串行执行。该demo主要为了保护counter,counter--指令执行完,就可以解锁,避免长时间串行,影响程序效率

这里不给出代码运行结果,尝试自己编写运行

深入理解锁

上面锁的用法也看了,锁确实能保护我们的票目counter,但是你有没有想过,多个线程之间虽然老老实实排队去抢票了,但是它们会竞争锁呀,毕竟谁先拿到锁,谁就能优先执行,多个线程都在竞争同一把锁,那锁是什么?没错,锁也是一种公共资源,那么加锁的过程中是不是也有中间状态,那么谁来保护锁呢? 

眼前先别黑,不需要谁来保护锁,操作系统给我们保证了加锁过程是原子性的,也就是加锁过程中不存在中间状态,用一条汇编指令就能完成

实现的方法很多,这里笔者讲一个比较通用的方法

下图是加锁的部分伪代码,也是加锁的核心

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第6张图片

我们需要有一个场景,还是用刚才抢票的那个demo,有线程A和B同时抢票 

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第7张图片

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第8张图片 Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第9张图片

这是锁能实现串行执行的原理,不过上述是线程A一路顺畅的拿到锁,有没有可能

线程A刚执行完movb $0, %al就被切走了呢

线程A刚执行到xchgb %al, mutex就被切走了呢

当然有可能,时间中断可能在任意一条汇编执行时就到来,加下来分别模拟一下这样的场景

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第10张图片

上图同时包含了前面提到了两种场景,都没有什么问题,伪代码中最关键的还是xchgb指令,给交换提供了一个绝对原子的操作, 执行xchgb指令,该线程禁止被中断或受到其它线程干扰,对于解锁,要求就没那么高,下面是解锁的伪代码

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第11张图片

封装锁

直接使用原生接口创建和调用锁,老是感觉不方便,毕竟是学C++的,就得用C++的方式给其原生接口封装一下,更符合现代编程的使用习惯,封装代码如下

#pragma once
#include
#include
#include
#include
class thread_mutex{
public:
    thread_mutex(pthread_mutex_t * mut):_mutex_p(mut)
    {       
         *_mutex_p = PTHREAD_MUTEX_INITIALIZER;     
    }

    void lock()
    {      
        pthread_mutex_lock(_mutex_p);
    }

    void trylock()
    {
        pthread_mutex_trylock(_mutex_p);
    }


    void unlock()
    {
        pthread_mutex_unlock(_mutex_p);
    }

private:
    pthread_mutex_t* _mutex_p;
};



#include
#include"C++_mutex.hpp"


int counter = 100;

pthread_mutex_t mutex;


void* start_routine(void* args)
{    
    thread_mutex _mutex(&mutex);

    while(true){
        _mutex.lock();

        if (counter > 0){          
            counter--;
            std::cout << "抢票用户:"<< (char*)args << " 剩余票数: " << counter << std::endl;

            _mutex.unlock();
            usleep(1234);                            

        }

        else{

            _mutex.unlock();

            break;
        }  
    }
    return nullptr;

}


int main()

{  

   pthread_t thread;

   char second_thread[] = "次线程";

   char main_thread[] = "主线程";

   pthread_create(&thread, NULL, start_routine, (void*)second_thread);

   start_routine((void*)main_thread);

   pthread_join(thread, NULL);

   return 0;

}

如果觉得解锁用的麻烦,我们可以利用智能指针的思想,写一个析构函数,把解锁接口调用放到析构函数中,等到类的作用域结束自动解锁,这里就不演示了

小技巧:可以用{ }自定义数据类型的的作用域

死锁 

锁真是个好东西啊,线程妈妈(进程)再也不怕小线程无序争夺资源,把一切都搞乱了

于是在多线程中,一旦涉及到公共资源争夺,就加一把锁,但是这么一加,就加出了问题

什么问题呢?看标题也明白了——死锁

起因是这样的,现在有公共资源A和B,公共资源A有一把锁,公共资源B也有一把锁,现在有线程1和2,线程1一开始要使用资源A,于是它把锁A给拿走了,线程2一开始要使用资源B,于是它把锁B给拿走了

线程1执行着突然发现需要资源B了,于是它等待线程2把资源B的锁还回来,不然它没法取资源B呀,可是线程2执行着发现需要资源A了,于是它等待线程1把资源A的锁还回来

线程2哪知道线程1还在等它呢?同样线程1也不知道线程2在等它呀,两个人就这样互相等啊等,没有终止,导致程序无法继续执行,这就是死锁问题

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第12张图片

可不是只有两个及以上个锁才会造成死锁问题,一个锁也会造成死锁问题,人也会被自己绊倒,更别说一根筋的电脑了

  while(true){

拿这个例子来说,把解锁的接口全给注释了,线程A拿到锁执行完一次循环后,会再次循环,再次申请
加锁,锁本来就在它身上,加锁接口伪代码咱们也看过了,可想而知线程A也将被挂起,且锁也丢了
        _mutex.lock();
        if (counter > 0){          
            counter--;
            std::cout << "抢票用户:"<< (char*)args << " 剩余票数: " << counter << std::endl;
            //_mutex.unlock();
            usleep(1234);                             
        }
        else{
            //_mutex.unlock();
            break;
        }   
    }

避免死锁的方法 

出现死锁有四个必要条件

1.互斥(某线程拿到锁,那么其它线程要保持互斥,不能取该锁保护的资源)

2.请求与保持:(死锁时,各线程互相请求对方的锁,互不相让)

3.不剥夺:(各线程平等,无权强行夺取其它线程的锁)

4.环路等待条件 (出现死锁问题组成的无法打破僵局的环路)

避免死锁就是不要同时满足上面的四个必要条件,解决死锁的方法就是打破上面的条件之一

例如使用线程的优先级,死锁时优先级低的线程必须主动释放锁

相关的算法有(死锁检测算法,银行家算法等)

线程同步 

什么是线程同步?线程不同步会有什么问题呢?其实咱们前面遇到过这个问题,笔者还解释了大半天,遗忘的同学前往文章开头处查看,用到的代码笔者已复制如下

当时笔者解释了半天,为什么要使用usleep(),因为线程不调度,导致票被主线程这一个线程给抢完了,或者是主线程的竞争能力太强了,它在解锁时同时也是离锁最近的,所以它一解锁,立马就循环再拿锁,次线程是一次锁都摸不到

#include
#include
#include
#include

int counter = 10;

//创建一个全局锁
pthread_mutex_t mutex;

void* start_routine(void* args)
{     
    while(true){

        //在这里加锁,保护公共资源counter
        pthread_mutex_lock(&mutex);
        if (counter > 0){          
            counter--;
            std::cout << "抢票用户:"<< (char*) args << " 剩余票数: " << counter << std::endl;
            //这里counter--已经执行完毕,公共资源保护完成,可以解锁
            pthread_mutex_unlock(&mutex);
            usleep(1234);                             
        }
        else{
            //这里是程序拿到锁,然而没票了,退出之前要解锁
            pthread_mutex_unlock(&mutex);
            break;
        }   
    }

    
    return nullptr;
}


int main()
{   
   pthread_t thread;
   char second_thread[] = "次线程";
   char main_thread[] = "主线程";

   //初始化该全局锁
   pthread_mutex_init(&mutex, NULL);

   pthread_create(&thread, NULL, start_routine, (void*)second_thread);
    
   start_routine((void*)main_thread);

    pthread_join(thread, NULL);

    return 0;
}

你说主线程违背了锁的竞争原则了吗?并没有,它是严格按照锁的竞争规则来的,但是你说这合理吗?这并不合理,主办方把票全部卖给了黄牛,即使你手速逆天,抢票时也只是卡顿一下,然后显示票已卖完

我们要避免票全让一个线程给抢完了,怎么办,简单粗暴的方法就是再加入一个排队系统,刚抢完票的线程不准再抢了,立马去排队,就能让其它的线程有机会抢到票,像这样避免一个线程独占资源而导致其它线程挨饿的就是线程同步(到这里大家应该能体会到,没写过类似的代码,看这部分内容就感觉很虚,一段时间后没有任何印象,所以请务必敲代码,亲自体验这个过程)

生产者与消费者模型 

大概了解什么是同步之后,我们来了解一个线程中很重要的模型——生产者与消费者模型

故事来源于生活场景,角色有:顾客,超市,工厂

我们每个人都是顾客,又称为消费者,我们需要商品满足自身生活需求,没有什么好说的。工厂是生产商品的,又称为生产者,有需求,就有人生产嘛,同样没有什么好说的

超市这个角色值得我们聊聊,为什么要有超市呢?

如果顾客直接去工厂买东西不可以吗?顾客作为一个单独的个体,其购买的产品量是很低的,如果每个顾客都来,那每次开机就生产那么一点点东西,赚得钱可能连电费都付不起,同样的,顾客想去买东西,还得等你工厂开机生产,等到生产完,可能天都黑了

可见我们不能把顾客与工厂强关联,需要一个中间区域,在这个中间区域里,顾客随拿随走,工厂可以批量生产有存储区域

可见,超市这个东西就是把顾客和工厂解耦的,如果生产者和消费者强耦合,消费者要等待生产时间,工厂要承担零售成本,有了超市解耦,消费者随拿随走,生产者没有零售成本

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第13张图片

大家感觉这个超市的作用熟不熟悉? 不就是咱们前面提到过的缓冲区吗?

顾客消费可以看到超市资源,工厂供货也可以看到超市资源,那么超市不就是公共资源吗?注意指在程序里的公共资源,引入生活中的例子是便于大家理解,但不可把生活中的经验全套入到改模型里来理解该模型

下面看看消费者与生产者之间的关系

消费者与消费者之间:互斥关系

现在超市某个货品只有一个,只有一个消费者可以拿,一个拿了另一个就不能拿了,所以构成互斥关系

生产者与生产者之间:互斥关系

超市的容量是有限的,一个工厂供货了,另一个工厂就不能再供货了,故生产者与生产者之间也构成了互斥关系

生产者与消费者之间:互斥,同步

互斥还是好理解的,生产者正在给超市供货呢,还没开始统计数量呢,消费者直接就进来把商品拿走了,这样是不行的,因此消费者访问公共资源时,生产者就不能访问公共资源,反之亦然,生产者和消费者之间构成互斥关系

假设现在生产者给超市供货,而不断有消费者来购买商品,那么超市和消费者时间都浪费了,也没得到商品。同样,假设没有消费者来超市消费,而不断有生产者前来供货,那么超市和生产者时间都浪费了,也没卖出商品

为了解决这个问题,超市设置了一种同步策略,即有货的时候再通知消费者,没货时消费者不要来,同样,缺货的时候通知生产者,不缺货生产者不要来

上述生产者和消费者模型可以归纳为“321”原则

3种关系(上述的三种关系)

2个角色(生产者线程,消费者线程) 

1个交易场所(一段特定结构的缓冲区,即上述超市)

现在有main函数和一个fun函数,main函数调用了fun函数,在正常情况下,main函数调用fun函数之后,fun函数开始执行,而main函数则在等待fun函数执行完毕。同样的main函数还没开始调用fun函数时,fun函数在等待main函数的调用

这里main函数和fun函数就是强耦合的关系,把这两个函数带入到生产者消费者模型

由main函数调用fun函数,所以main函数是参数的提供方(生产者),fun函数是参数的使用方(消费者)如果由两个线程来同时执行这个函数,消费者线程和生产者线程同时开始,同时设立一定的执行条件,当消费者需要数据时,而生产者还没有生产好数据,那么就挂起等待,等到生产者生产好了,满足条件了,就可以唤醒消费者,反之同理

条件变量 

什么是条件变量呢? 我们前面提到过,在生产者和消费者模型中,生产者和消费者之间要有互斥和同步的关系,互斥解决方法就是加锁嘛,条件变量就是解决同步的一种常用的方法之一,上面的模型中,超市就是公共资源,消费者消费资源,生产者生产资源,当公共资源没有了,不满足消费者的条件,那么此时消费者不能再来了,老实的挂起等待,反之同理

条件变量维护了一个不满足条件就挂起,满足条件就唤醒的队列,条件变量要和锁一起配合使用,从而满足互斥和同步的关系

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第14张图片

所以什么是条件变量呢?其实就是在加锁后,为了维持线程同步,加了一个判断条件,满足条件的可以继续执行,不满足条件的需要挂起等待,条件变量提供了一个队列,这个队列专门用来存放这些不满足条件的线程

消费者线程去超市这个公共资源区去消费,但是此时超市已经没有货物了,所以消费者线程不满足进入超市的条件,去到条件变量里挂起等待,假设此时生产者来了,它检测到超市的货物没有满,可以供货,于是进入了超市这个公共资源区开始供货,同时供货完,它会从条件变量里唤醒一个线程,若该线程是消费者线程,此时判断超市已经有货了,于是它可以进入超市去消费资源了

条件变量的相应接口 

条件变量的概念明白了,接下来就看看条件变量如何使用吧。有时你可能会看到笔者在接口和函数之间反复横跳,其实叫接口也好,叫函数也罢,两者是同一个东西,叫函数是从编程语言的角度看待,叫接口是从系统调用的角度来看待的,废话不多说,看接口

条件变量同锁一样,都是一种数据类型,里面包含了各种需要的数据结构 

条件变量的数据类型为:pthread_cond_t  

声明一个条件变量: pthread_cond_t  cond;

同样,声明完要进行初始化

初始化:int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);第二个参数填NULL即可

另一种初始化方式:pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_cond_destroy(pthread_cond_t *cond);

这个比较好理解,就是把你创建的条件变量销毁

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
参数:
cond:要在这个条件变量上等待
mutex:互斥量,后面详细解释

该接口的意思是,如果判断条件不满足,那么就调用该接口,系统会把不满足条件的线程放入到条件变量的等待区中

int pthread_cond_signal(pthread_cond_t *cond);
当满足条件之后,通过调用该接口,系统会通知在条件变量里等待的线程,可以开始执行了,注意该接口只能唤醒一个线程

int pthread_cond_broadcast(pthread_cond_t *cond);
该接口和上面接口的作用是一样的,不过该接口不只是唤醒一个等待区的线程,而是唤醒一批处在等待变量中的线程

条件变量代码实操 

废话不多说,直接用起来,下面是测试条件变量的demo

注:为了简便,后面称呼这些接口调用函数只用后缀代替

例如:pthread_cond_wait() 用wait简称,其它接口类似

int counter = 100;
pthread_mutex_t mutex;
pthread_cond_t cond;

void *start_routine(void *args)
{
    thread_mutex _mutex(&mutex);
    while (true)
    {
        _mutex.lock();
        if (counter > 0)
        {
            pthread_cond_wait(&cond, &mutex);
            counter--;
            std::cout << "抢票用户:" << (char *)args << " 剩余票数: " << counter << std::endl;
            _mutex.unlock();
            // usleep(1234);
        }
        else
        {
            _mutex.unlock();
            break;
        }
    }

    return nullptr;
}

int main()
{
    pthread_t thread_1, thread_2;
    cond = PTHREAD_COND_INITIALIZER;
    char name_1[] = "抢票选手1";
    char name_2[] = "抢票选手2";

    pthread_create(&thread_1, NULL, start_routine, (void *)name_1);
    pthread_create(&thread_2, NULL, start_routine, (void *)name_2);

    while (true)
    {
        pthread_cond_signal(&cond);
        sleep(1);
    }

    pthread_join(thread_1, NULL);
    pthread_join(thread_2, NULL);

    return 0;
}

该代码用到了前面对锁的封装,主要思想就是创建两个子线程,两个子线程刚进入抢票就被wait,进入条件变量挂起等待,然后由主线程用signal逐一唤醒挂起的进程,开始抢票

理解条件变量 

等等,老是觉得有些不太对劲,其一在使用条件变量的wait时,为什么要把锁传进去。其二我们不是加锁了嘛,既然加锁了就该保持互斥,也就是只有一个线程才能拿到锁,才能遇到wait,然后进入条件变量等待区,为什么上面的demo思想却说让两个子线程都进入条件变量挂起等待,等待主线程逐一将它们唤醒呢

我们的理解并没有错,只是前面没提到在wait时把锁传过去的作用,wait接口把锁传过去就是为了释放锁,因为释放了锁,其它线程才有机会进入公共资源区。假设现在有一个生产者线程和一个消费者线程,此时公共资源区已经没有资源了,所以消费者进来就得把它挂起等待,如果它把锁也带到等待区而不释放,那么生产者就进入不了公共资源区,那程序就卡死了,生产者永远进不去,消费者永远醒不来

基于BlockingQueue的生产者消费者模型

看标题是不是觉得特别深奥,但仔细看不就是基于阻塞队列的生产者消费者模型嘛,啥意思呢?就是建立一个队列,这个队列的大小是固定的,生产者不断往这个队列中写入数据,消费者不断往这个队列拿出数据,当写入速度明显大于拿出速度时,队列将被写满,就会触发条件判断,把生产者都放到条件变量等待区里。同样的,当拿出速度明显大于写入速度导致队列里没有数据了,会触发条件判断,将消费者放入条件变量的等待区里

了解功能大家可以自行实现,请务必自行实现,下面笔者给出一些参考代码 

#include
#include
#include
#include
#include
#include
#include


template< class T>
class thread_cond{
public:
    thread_cond()
    {
        _cond = PTHREAD_COND_INITIALIZER;
    }

    void thread_cond_push(T data, pthread_mutex_t *mutex)
    {
        if (_buffer.size() >= _capacity)
        {   
            pthread_cond_wait(&_cond, mutex);
        }
        _buffer.push(data);
        pthread_cond_signal(&_cond); 
    }

    T thread_cond_get(pthread_mutex_t *mutex)
    {
        if (_buffer.size() <= 0)
        {
            pthread_cond_wait(&_cond, mutex);
        }

        T rt_val = _buffer.front();
        _buffer.pop();
        pthread_cond_signal(&_cond);
        return rt_val; 
    }

    ~thread_cond()
    {
        pthread_cond_destroy(&_cond);
    }

private:
    std::queue _buffer;
    pthread_cond_t _cond;
    size_t _capacity = 100;
};



----------------------------------------------------------------------------



pthread_mutex_t mutex;

void* start_get(void *args)
{
    thread_cond * test_cond = (thread_cond*)args;
    while(true)
    {
        pthread_mutex_lock(&mutex);
        int temp = test_cond->thread_cond_get(&mutex);
        std::cout << "线程:"< * test_cond = (thread_cond*)args;
    while(true)
    {
        pthread_mutex_lock(&mutex);
        int temp = rand()%100;
        test_cond->thread_cond_push(temp, &mutex);
        std::cout << "线程:"< test_cond;
    pthread_mutex_init(&mutex, NULL);
    std::vector threads(4);
    pthread_create(&threads[0], NULL, start_get, (void*)&test_cond);
    pthread_create(&threads[1], NULL, start_get, (void*)&test_cond);
    pthread_create(&threads[2], NULL, start_push, (void*)&test_cond);
    pthread_create(&threads[3], NULL, start_push, (void*)&test_cond);

    for (int i = 0; i < 4; i++)
    {
        pthread_join(threads[i], NULL);
    }
    
    return 0;
}

用模板来编写该类,主要是为了支持泛型,方便日后工作的扩展,现在我们传过去的是int类型的数据,日后可能会是一个自定义类型的类

生产者消费者模型的意义

下图是生产者,消费者模型的简述图

Linux系统编程6(线程互斥,锁,同步,生产消费模型)_第15张图片

你会不会有这样的疑问,我们引入多线程就是为了实现程序并发,提高工作效率。但是这个生产者消费者模型,消费者想拿数据还是只能加锁一个一个的进入,同样的生产者想放入数据也是只能加锁一个一个的进入,甚至消费者和生产者之间也不能同时进入,那这并发的意义在哪里呢?既然都是一个一个的串入式进入,为何不用单线程呢?

有这样的疑惑是因为我们正在讲述生产者消费者模型,大家都把目光聚焦到这个模型中,但是这个模型仅仅是负责资源的纳入和分配,而不涉及资源的生产和处理

什么意思呢?消费者来到公共资源区是为了拿取资源,而真正消耗时间的是资源的消费过程,但是这个过程并不是在公共资源区内部进行的

同样的,生产者把生产好的数据放入公共资源区,真正消耗时间的是资源的生产过程,这个生产过程也不是在公共资源区进行的

所以多线程并发的意义并不在公共资源区中串型式的拿取增添数据,而是并行式的消费资源和生产资源,加锁是保证资源拿取和增添的安全有效,这个过程并不怎么消耗时间

你可能感兴趣的:(Linux(基础使用,系统编程,网络编程),linux,服务器)