多线程+互斥+条件变量题目

已于 2024-04-07 00:18:17 修改
阅读量872 收藏 28
点赞数 23
分类专栏： 题目解析 文章标签： 题目 c++ 多线程 条件变量 互斥
于 2024-04-06 15:02:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cefler/article/details/137424696
版权
本文介绍了如何使用C++的线程库和条件变量来实现线程A和线程B的交替打印，以及生产者消费者模型的两种版本，重点讲解了条件变量的使用和同步机制的改进。
摘要由CSDN通过智能技术生成

在这里插入图片描述

欢迎来到Cefler的博客😁
🕌博客主页：折纸花满衣
🏠个人专栏：题目解析

在这里插入图片描述

目录

👉🏻 完成两个线程通过条件变量实现交替打印

1.题目描述：线程A打印-我是线程A；线程B打印-我是线程B； 最终实现交替打印，不能出现连续的相同打印。

2.本题主要考察条件变量的基本使用流程

错误代码加优化(c++线程库版本)

#include<iostream>
#include<mutex>
#include<thread>
#include<condition_variable>
#include<unistd.h>

using namespace std;
mutex mx;//互斥锁
condition_variable cv;//条件变量

bool flag = true;
void Print(char args)
{
    char c = static_cast<char>(args);
     for (int i = 0; i < 5; i++)
    {
        unique_lock<mutex> lock(mx); // 上锁
        //if(!flag)
        cv.wait(lock,[]{return flag;}); // 等待条件 flag 为 true[]{return flag||!flag;}
        if(c=='A')
        cout << "我是线程A" << endl;
        else if(c=='B')
        cout<<"我是线程B"<<endl;
        flag = !flag;
        cv.notify_one(); // 通知另一个线程
        sleep(1);

    }
}
int main()
{
    //创建AB线程
    std::thread threadA(Print,'A');
    std::thread threadB(Print,'B');

     // 等待线程结束
    threadA.join();
    threadB.join();

    return 0;
}

在这里插入图片描述
此代码会导致第一次打印字符A后就阻塞不动了，
主要原因出在这行代码上

cv.wait(lock,[]{return flag;});

wait的第二个参数是个函数对象(这里是lamda表达式)，当返回值是false时,wait会进行阻塞，true时,wait会开始释放锁，当前线程拿到锁后开始继续执行。
因为flag一开始为true,所以此时线程A是拿到锁并执行打印工作的。
而后将flag改为false，并去唤醒线程B(唤醒它来看看wait是否满足情况了),此时第二次循环进来,线程A会被wait阻塞住。
而线程B这边已经苏醒，过来第一次循环，结果被阻塞，这是怎么回事？因为flag被改为false了，所以线程B阻塞了，而此时线程A同时也被阻塞，直接导致两个线程统统被阻塞，所以这个wait的判定条件是个大问题。
要解决的话就是将线程A和线程B进来的不同情况都要考虑进去。

代码优化如下:

#include<iostream>
#include<mutex>
#include<thread>
#include<condition_variable>
#include<unistd.h>

using namespace std;
mutex mx;//互斥锁
condition_variable cv;//条件变量

bool flag = true;
void Print(char args)
{
    char c = static_cast<char>(args);
     for (int i = 0; i < 5; i++)
    {
        unique_lock<mutex> lock(mx); // 上锁
        cv.wait(lock,[&]{return c=='A'&&flag||c=='B'&&!flag;}); // 等待条件 flag 为 true[]{return flag||!flag;}
        cout<<"我是线程"<<c<<endl;
        flag = !flag;
        cv.notify_one(); // 通知另一个线程
        sleep(1);

    }
}


int main()
{
    //创建AB线程
    std::thread threadA(Print,'A');
    std::thread threadB(Print,'B');

     // 等待线程结束
    threadA.join();
    threadB.join();

    return 0;
}

在这里插入图片描述

版本2（使用phtread.h库）

#include<iostream>
#include<pthread.h>
#include<unistd.h>
using namespace std;

//声明互斥锁和条件变量
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cv = PTHREAD_COND_INITIALIZER;

bool flag = false;
void* Print(void* args)
{
    char c = *(static_cast<char*>(args));

    for(int i = 0;i<5;i++)
    {
        //先上锁为敬
        pthread_mutex_lock(&mtx);
        //判断条件变量
        while(c=='A'&&flag||c=='B'&&!flag)
        {
            pthread_cond_wait(&cv,&mtx);//线程阻塞，等待唤醒
        }
        cout<<"我是线程"<<c<<endl;
        flag = !flag;
        sleep(1);
        pthread_cond_signal(&cv);//唤醒其它线程
        pthread_mutex_unlock(&mtx);//解锁，当其它线程被唤醒时能拿到锁

        
    }
    return nullptr;
}
int main()
{
    //1.线程声明
    pthread_t threadA,threadB;
    char c1 = 'A',c2 = 'B';

    //2.创建线程
    pthread_create(&threadA,nullptr,Print,(void*)&c1);
  
    pthread_create(&threadB,nullptr,Print,(void*)&c2);

    //3.线程等待回收
    pthread_join(threadA,nullptr);
    pthread_join(threadB,nullptr);

    //4.互斥锁和条件变量销毁
    pthread_mutex_destroy(&mtx);
    pthread_cond_destroy(&cv);

    return 0;
}

这里有几个需要注意的要点：
1.pthread_create中的线程函数返回值必须是void类型的，参数为void，也就是指针类型

2.使用 while 循环则可以避免虚假唤醒的问题。当线程被唤醒时，它会重新检查条件是否满足。如果条件不满足，线程将继续等待，直到条件满足为止。这样可以确保线程在接收到正确的信号时才会继续执行。

👉🏻按序打印

原题链接:按序打印

mycode:


class Foo {
mutex mtx;
condition_variable cv;
int num = 0;
public:
    Foo() {
        
    }

    void first(function<void()> printFirst) {
        
        // printFirst() outputs "first". Do not change or remove this line.
        unique_lock<mutex> lock(mtx);
        cv.wait(lock,[&]{return num==0;});
        printFirst();
        num = (num+1)%3;
        cv.notify_all();//唤醒全部线程
    }

    void second(function<void()> printSecond) {
        
        // printSecond() outputs "second". Do not change or remove this line.
        //上锁
          unique_lock<mutex> lock(mtx);
        cv.wait(lock,[&]{return num==1;});
        printSecond();
        num = (num+1)%3;
        cv.notify_one();//唤醒一个线程
    }

    void third(function<void()> printThird) {
        
        // printThird() outputs "third". Do not change or remove this line.
          unique_lock<mutex> lock(mtx);
        cv.wait(lock,[&]{return num==2;});
        printThird();
        num = (num+1)%3;
        //cv.notify_one();//唤醒一个线程
    }
};

这里要注意的是唤醒线程只需要一个notify_all和notify_one就行了，这样就只会执行3次操作而已，不会过多导致时间超时
为什么呢？因为不管哪个函数先进入,如果因为条件不满足，会堵塞在那里，等待被唤醒，一个notify_all先将其余两个线程唤醒,此时这两个线程过来查看条件变量情况，一个会成功，一个会失败阻塞，这个时候还差一个线程还没执行完全在等待，就再来一个notify_one唤醒即可。

👉🏻 H2O 生成

原题链接:H2O 生成

mycode:

int num_h = 0;
class H2O {
mutex mtx;
condition_variable cv;
public:
    H2O() {
        
    }

    void hydrogen(function<void()> releaseHydrogen) {
        
        // releaseHydrogen() outputs "H". Do not change or remove this line.
         unique_lock<mutex> lock(mtx);
        cv.wait(lock,[&]{return num_h<2;});//H的数量要小于2
        releaseHydrogen();
        ++num_h;
        cv.notify_all();//唤醒氧线程
    }

    void oxygen(function<void()> releaseOxygen) {
        
        // releaseOxygen() outputs "O". Do not change or remove this line.
        unique_lock<mutex> lock(mtx);
        cv.wait(lock,[&]{return num_h==2;});
        num_h = 0;//H与O匹配消耗完后清空
        releaseOxygen();
        cv.notify_all();//唤醒氢气线程
    }
};

👉🏻生产者消费者模型实现

版本1

#include<iostream>
#include<vector>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<unistd.h>
using namespace std;

const size_t BUFFER_SZ = 10;

vector<int> buffer;
mutex mtx;
condition_variable cv;

void Consumer(void* args)
{
    const char* name = static_cast<const char*>(args);

    for(int i = 0;i<BUFFER_SZ;i++)
    {
        //1.上锁
        unique_lock<mutex> lock(mtx);
        //2.条件变量
        cv.wait(lock,[]{return buffer.size()>0;});//缓冲区得有数据才能消费
        int data = buffer.back();
        printf("%s取走了数据%d,此时缓冲区数据数量有:%d\n",name,data,buffer.size());
        buffer.pop_back();
        sleep(2);//我们让消费者消费慢一点
        lock.unlock();
        cv.notify_one();//唤醒生产者线程
    }
}
void Productor(void* args)
{
    const char* name = static_cast<const char*>(args);

    for(int i = 0;i<BUFFER_SZ;i++)
    {
        //1.上锁
        unique_lock<mutex> lock(mtx);
        //2.条件变量
        cv.wait(lock,[]{return buffer.size()<=BUFFER_SZ;});//缓冲区得有数据才能消费
        buffer.push_back(i);
        printf("%s生产了数据%d,此时缓冲区数据数量有:%d\n",name,i,buffer.size());
        sleep(1);
        lock.unlock();
        cv.notify_one();//唤醒消费者线程,有数据给你消费了快来
    }
}
int main()
{
    thread consumer(Consumer,(void*)"Consumer");
    thread productor(Productor,(void*)"Productor");

    //线程回收
    consumer.join();
    productor.join();
    return 0;
}

效果如下：
在这里插入图片描述

这里和我理想的好像不一样，这里是全部生产完再消费，并没有实现生产和消费同步

更改之后：

#include<iostream>
#include<vector>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<unistd.h>
using namespace std;

const size_t BUFFER_SZ = 10;

vector<int> buffer;
mutex mtx;
condition_variable cv_consumer;
condition_variable cv_productor;


void Consumer(void* args)
{
    const char* name = static_cast<const char*>(args);

    for(int i = 0;i<BUFFER_SZ;i++)
    {
        //1.上锁
        unique_lock<mutex> lock(mtx);
        //2.条件变量
        cv_consumer.wait(lock,[]{return buffer.size()>0;});//缓冲区得有数据才能消费
        int data = buffer.back();
        printf("%s取走了数据%d,此时缓冲区数据数量有:%d\n",name,data,buffer.size());
        buffer.pop_back();
        
        lock.unlock();
        cv_productor.notify_one();//唤醒生产者线程
        sleep(2);//我们让消费者消费慢一点
    }
}
void Productor(void* args)
{
    const char* name = static_cast<const char*>(args);

    for(int i = 0;i<BUFFER_SZ;i++)
    {
        //1.上锁
        unique_lock<mutex> lock(mtx);
        //2.条件变量
        cv_productor.wait(lock,[]{return buffer.size()<=BUFFER_SZ;});//缓冲区得有数据才能消费
        buffer.push_back(i);
        printf("%s生产了数据%d,此时缓冲区数据数量有:%d\n",name,i,buffer.size());
       
        lock.unlock();
        cv_consumer.notify_one();//唤醒消费者线程,有数据给你消费了快来
         sleep(1);
    }
}
int main()
{
    thread consumer(Consumer,(void*)"Consumer");
    thread productor(Productor,(void*)"Productor");

    

    //线程回收
    consumer.join();
    productor.join();
    return 0;
}

主要更改点:

lock.unlock();
        cv_productor.notify_one();//唤醒生产者线程
        sleep(2);//我们让消费者消费慢一点

lock.unlock();
        cv_consumer.notify_one();//唤醒消费者线程,有数据给你消费了快来
         sleep(1);

1.在notify_one前unlock:这里因为我们要实现的就是同步，注意，同步！，如果不手动unlock会导致，比如这里是我将消费者唤醒了，但是如果生产者notify后还有做事情(sleep)，互斥锁的生命周期还没结束也就是还没自动释放互斥锁，此时消费者被唤醒了也只能在那尴尬着什么都干不了。结果呢，当生产者终于进入下个循环时，当互斥锁自动释放后，在新的循环里，生产者又加锁了，可谓无缝衔接，所以，根本没有机会留给消费者
所以对症下药，我们可以这么做：

  • 可以不unlock,但是notify后别再sleep做其它耗时的事情了：但是这样子速度就太快了，在观察的时候不好看
  • 所以还是nitify前unlock才行
    2.sleep放在unlock后面:当锁释放后，

版本2

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <condition_variable>
#include<unistd.h>

const int BUFFER_SIZE = 10;

std::vector<int> buffer;
std::mutex mtx;
std::condition_variable bufferNotEmpty;
std::condition_variable bufferNotFull;
std::condition_variable cv;


void producer() {
    for (int i = 0; i < 20; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return buffer.size() < BUFFER_SIZE; });
        buffer.push_back(i);
        std::cout << "Produced: " << i << std::endl;
        lock.unlock();
        cv.notify_one();
        //std::this_thread::sleep_for(std::chrono::milliseconds(500));

        sleep(1);
    }
}

void consumer() {
    for (int i = 0; i < 20; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !buffer.empty(); });
        int item = buffer.back();
        buffer.pop_back();
        std::cout << "Consumed: " << item << std::endl;
        lock.unlock();
        cv.notify_one();
        //std::this_thread::sleep_for(std::chrono::milliseconds(700));

        sleep(2);
    }
}

int main() {
    std::thread producerThread(producer);
    std::thread consumerThread(consumer);

    producerThread.join();
    consumerThread.join();

    return 0;
}

这里弄了两个条件变量主要是为了区分唤醒生产者线程和消费者线程，因为这里只有一个生产者线程和一个消费者线程所以其实定义一个条件变量也就够了。
但是为了规范点，如果以后遇到多个生产者线程和多个消费者线程，就必须用对应的条件变量去阻塞且唤醒相关类型的线程！

如上便是本期的所有内容了，如果喜欢并觉得有帮助的话，希望可以博个点赞+收藏+关注🌹🌹🌹❤️ 🧡 💛,学海无涯苦作舟,愿与君一起共勉成长

在这里插入图片描述
在这里插入图片描述

cefler
关注
  • 23
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CC++多线程编程练习题大全
06-12
2. **线程同步与互斥**：为避免多线程间的竞态条件，需要使用同步机制。C++提供了`std::mutex`来实现互斥锁，保证同一时间只有一个线程访问共享资源。`std::lock_guard`是RAII（Resource Acquisition Is ...
创建线程，利用互斥实现线程共享变量通信
05-24
一、题目: 创建线程，利用互斥实现线程共享变量通信 二、目的 掌握线程创建和终止，加深对线程和进程概念的理解，会用同步与互斥方法实现线程之间的通信。 三、内容和要求 软件界面上点“创建线程” 按钮，创建三个...
一道题分析和实现 多线程之互斥量和条件变量的配合使用
lzb991435344的博客
08-06 136
题目：使用多线程，要求按序打印出4次abcd 1.只使用互斥量mutex 忙等，直到能够获得进入临界区的条件 #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <string.h> #define THRNUM 4 //print abcd to stdout //4个互斥量之间协作 static pthread_mut
Linux线程管理实验——互斥锁和条件变量
吴立赛的博客
11-29 1061
1.互斥锁基本原理        互斥锁提供了对临界资源以互斥方式进行访问的同步机制。简单来说，互斥锁类似于一个布尔变量，它只有“锁定”和“打开”两种状态，在使用临界资源时线程先申请互斥锁，如果此时互斥锁处于“打开”状态，则立刻占有该锁，将状态置为“锁定”。此时如果再有其他线程使用该临界资源时发现互斥锁处于“锁定”状态，则阻塞该线程，直到持有该互斥锁的线程释放该锁。通过这样的机制保证在使用临界资源时数据不会被另外一个线程破坏。 2.条件变
linux线程间同步(互斥量与条件变量)
guoweilkd的博客
12-05 370
linux线程间同步(互斥量与条件变量) linux的线程有两个重要的同步方式。分别为互斥量(mutex)和条件变量(condition variables).其中linux下互斥量功能类似RTOS下的互斥量。用于防止多个线程同时访问同一共享资源。而条件变量在共享资源发生变化时用来通知其他线程。互斥量与条件变量结合使用时类似RTOS下的事件。 互斥量(mutex) linux的互斥量机制与RTOS下的互斥量机制一样。主要用于防止多个线程同时访问同一共享资源。 初始化条件变量时可以使用静态初始化和动态初始化：
互斥量与条件变量
记录学习的点滴
05-09 1137
我想在这里先说一个跟题目无关的东西，一种学习方法，叫费曼学习法。简单的说，费曼学习法有四个步骤，学习知识要把它教给小孩子、回顾、将语言条理化、传授。 初步理解 在这里我想先用自己的话来描述互斥量和条件变量这两个概念和他们之间的关系。计算机中的一些资源可以被不同的线程共享，但是他们在某个时刻只能被一个线程使用，为了防止某个线程正在使用该资源时被别的线程使用导致线程运行出现错误，我们需要用“锁”这一概念，把共享的资源在使用前锁上，使得该资源只会被它正在使用的线程访问，并在使用后进行解锁。这就是互斥量的概念。互斥
C++多线程同步的5种方式：互斥锁mutex、条件变量condition_variable、信号量sempahore、异步操作future、原子操作atomic
欧特GO
08-30 1834
C++多线程同步的5种方式讲解：互斥锁mutex、条件变量condition_variable、信号量sempahore、异步操作future、原子操作atomic。
多线程再体验：使用条件变量解决生产者、计算者、消费者问题，使用条件变量实现 ping-pong 问题
Alkali!的博客
05-01 382
理论知识 https://www.linuxmooc.com/courses/pthread/ job8/pc.c: 使用条件变量解决生产者、计算者、消费者问题 题目 思路 由题意可以的如下条件： 生产者之间互斥写共享缓冲区buffer1buffer1buffer1 消费者之间互斥读共享缓冲区buffer1buffer1buffer1 生产者与消费者之间互斥访问共享缓冲区buffer1buffer1buffer1 消费者之间互斥写共享缓冲区buffer2buffer2buffer2 计算者之间互斥读共
互斥锁和条件变量
qq_32783703的博客
07-29 174
互斥锁和条件变量 怎样多个线程或者多个进程同步活动。为允许在线程或进程之间共享数据，同步是必须的，互斥所和条件变量是同步的基本组成部分。 互斥锁和条件变量出自posix.1的线程标准，它们总是可用来同步一个进程内的各个线程的。如果一个互斥所或者条件变量存放在多个进程间共享某个内存区中，那么posix还允许它用于这些进程的同步。 本章介绍了生产生产者和消费者的问题，饼子啊解决这个问题的方案中使...
C++ 多线程编程 —— 条件变量（condition_variable）【多线程面试常见题型】
Aliven888的博客
04-24 681
条件变量（Condition variable）是在C++ 11时引入的。它是一个对象，该对象能够阻塞调用线程，直到被通知恢复。
多线程编程-互斥锁/条件变量/关卡的使用实例
shuaixio的博客
08-31 939
多线程编程，条件变量，互斥锁，barriers
java多线程面试题59题集合
03-15
- volatile关键字：确保多线程环境下变量的可见性，但不保证原子性。 - Lock接口与ReentrantLock：提供更细粒度的锁控制，可尝试获取锁、释放锁、检查是否持有锁等。 - wait(), notify(), notifyAll()：Object类...
利用互斥实现多线程同步
10-08
本文将深入探讨互斥实现多线程同步的基本原理、使用方法以及源代码实例。 一、互斥量（Mutex）基础 1. 定义：互斥量是一个同步对象，它允许一个线程对其拥有并保持独占状态，直到该线程释放它。当一个线程试图获取...
多线程实现30个人抢五个座位
12-21
本题目“多线程实现30个人抢五个座位”是一道典型的多线程同步问题，用于考察程序员对并发控制的理解和应用。下面我们将详细探讨这个问题的解决方案及其背后的原理。 首先，代码中定义了一个名为`Seat`的类，该类...
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1098
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 217
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 153
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
C++ std::thread 管理线程生命周期：join 和 detach
最新发布
m0_59680769的博客
07-16 977
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值