C++ 线程 任务队列

已于 2022-10-24 12:36:21 修改
阅读量4.6k 收藏 35
点赞数 9
分类专栏： 线程 文章标签： C++ 线程 任务队列 1024程序员节
于 2020-01-18 12:55:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langwang122/article/details/104028294
版权

任务队列有点像windows的消息循环，有任务被压进队列就执行任务，否者就一直等待任务的到来。这样做的好处是外部程序不需要关心队列线程中的同步，只需要将任务压进队列即可，非常的方便。比如现在有一个下载任务要做，没有线程队列的情况下要自己创建线程，编写线程回调，在线程中下载并写文件落盘，必要的时候还要通知界面下载进度，下载完成后还要将线程销毁，有一系列的细节要处理。有了任务队列后只需要编写下载任务，然后将其压到队列中去等待执行即可，这样就屏蔽了线程相关的细节，让重点落在任务的本身。当然也会有缺点，比如任务队列繁忙的时候就要等待其他任务执行完成；比如想要多个任务并行就要创建多个任务队列等。

1、任务

任务是任务队列的执行单位（这不是废话么->->），一个任务应该有任务的开始入口点，这些入口点应该都一致，否者对于不同的任务任务队列就不好统一处理；任务还应该有一个停止入口，用来防止想要停止正在执行的任务。那么对于这个任务的简单抽象可以是这样的：

class ITask
{
public:
    virtual ~ITask()
    {

    }

    /** 执行任务
    */
    virtual void DoTask() = 0;

    /** 停止任务
    */
    virtual void Stop() = 0;
};

使用者只要继承该接口，实现他的DoTask() 和Stop() 即可，如果需要参数的可以放到成员变量中去。

有的时候我们希望在任务执行的过程中可以给外部一些反馈，比如下载任务通知外部下载的进度等，我们可以这样来定义任务：


class DownTask :
    public ITask
{
public:
    DownTask(const std::function<void(int,int)>& callback) :
        m_callback(callback)
    {

    }

    virtual ~DownTask()
    {

    }

    /** 执行任务
    */
    virtual void DoTask()
    {
        // 下载的代码，可以调用CallBack来通知外界进度
    }

    /** 停止任务
    */
    virtual void Stop() 
    {
        // 如果需要的可以实现这个接口，一般是定义一个标记量flag，DoTask每次循环判断
        // 标记，如果为假就停止
    }


    void CallBack(int all, int cur)
    {
        if (m_callback != NULL)
        {
            m_callback(all, cur);
        }
    }

protected:
    /** 回调
    */
    std::function<void(int, int)> m_callback;
};

需要注意的是，回调函数是在线程中执行的，访问全局资源是有同步问题的，所以一般来说最好不要在回调中访问需要同步的全局资源，或者直接在回调中封装一个任务压到另外一个队列中去，比如下载进程中可以在回调中发消息到主界面（主界面的消息循环实际上也相当与一个任务队列），对于下载进程来说可以将窗口的句柄直接给任务对象，就不需要callback了，需要说明的是这样做并不是很好，因为我们并不知道这个句柄是否还有效，它有可能已经失效了变成一个野指针（给一个无效但是不为空的句柄发消息是一个未定义行为，可以使用week_ptr来确保指针的有效，但是本文并不讨论）。

2、线程队列

创建一个类，里面维护一个线程和一个队列，在线程的回调函数中不停的循环检测队列中是否有有效的任务，如果有就执行，没有就等待。比如：


class SimpleTaskQueue :
    public NonCopyable
{
public:
    /** 构造函数
    */
    SimpleTaskQueue();

    /** 析构函数
    */
    ~SimpleTaskQueue();

public:
    /** 开始循环
    @return 是否成功
    */
    bool Start()
    {
        m_pThread = new (std::nothrow) std::thread(&SimpleTaskQueue::ThreadCallBack, this);
        return (m_pThread != NULL);
    }


public:
    /** 线程回调
    */
    virtual void ThreadCallBack()
    {
        while (1)
        {
            if (m_taskQue.size() > 0)
            {
                auto task = m_taskQue.front();
                m_taskQue.pop();
                task->DoTask();
            }
        }
    }

private:
    /** 线程
    */
    std::thread* m_pThread;

    /** 任务队列
    */
    std::queue<std::shared_ptr<ITask> > m_taskQue;
};

有了循环后还需要将任务压进队列里的接口，在定义接口之前还要考虑一个问题，线程中一直不停的取队列，另外一个线程中向队列里压任务，那么就需要同步，将循环改成：

    /** 线程回调
    */
    virtual void ThreadCallBack()
    {
        while (1)
        {
            std::shared_ptr<ITask> spTask = NULL;
            // 取出队首
            {
                std::lock_guard<std::recursive_mutex> lock(m_mutex);

                if (m_taskQue.empty())
                {
                    continue;
                }

                spTask = m_taskQue.front();
                m_taskQue.pop();

                if (spTask == nullptr)
                {
                    continue;
                }
            }
            
            spTask->DoTask();
            
        }
    }

需要注意的是DoTask一定不能放到花括号内被mutex保护。压任务的代码：

void PushTask(const std::shared_ptr<ITask>& task)
{
    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    m_taskQue.push(task);
}

好了简单任务队列就完成了。

3、任务队列的润色

上述代码其实并没有什么用，有两个问题：

1、没有停止循环的接口，也没有停止当前任务的接口；这个问题很好解决，想要停止循环只要加上一个flag即可，想要停止当前任务只要将当前执行的任务记录下来，需要停止的时候调用任务的stop即可。

2、没有任务的时候循环一直空转，占用了大量的cup。这个问题有两个解决方案：
      a:循环时没有任务时候加上Sleep(0)释放cpu的使用权。（这个方法简单却不是很好，但是可以衍生出另外一种方法，会在后续文章中给出，本文不讨论）

      b:使用事件event，没有任务的时候等待任务，有任务的时候执行，很像生产者消费者模型，只不过只有一个消费者而已。

对于第一个问题，修改代码如下：

class SimpleTaskQueue :
    public NonCopyable
{
public:
    /** 构造函数
    */
    SimpleTaskQueue():m_stop(false),m_pThread(nullptr){};

    /** 析构函数
    */
    ~SimpleTaskQueue()
	{
        if (m_pThread != nullptr)
        {
            StopAll();
            m_pThread->join();
            delete m_pThread;
            m_pThread = nullptr;
        }
    };

public:
    /** 开始循环
    @return 是否成功
    */
    bool Start()
    {
        m_pThread = new (std::nothrow) std::thread(&SimpleTaskQueue::ThreadCallBack, this);
        return (m_pThread != NULL);
    }

    void StopAll()
    {
        std::lock_guard<std::recursive_mutex> lock(m_mutex);
        ClearAll();
        m_stop = true;
    }

    void StopCurrent()
    {
        std::lock_guard<std::recursive_mutex> lock(m_mutex);
        
        if (m_currentTask != nullptr)
        {
            m_currentTask->Stop();
        }
    }

    void ClearAll()
    {
        std::lock_guard<std::recursive_mutex> lock(m_mutex);
        StopCurrent();
        ClearQueue();
    }

    void ClearQueue()
    {
        std::lock_guard<std::recursive_mutex> lock(m_mutex);
        std::queue<std::shared_ptr<ITask> > tmp = std::queue<std::shared_ptr<ITask> >();
        m_taskQue.swap(tmp);
    }

    void PushTask(const std::shared_ptr<ITask>& task)
    {
        std::lock_guard<std::recursive_mutex> lock(m_mutex);
        m_taskQue.push(task);
    }
	
public:
    /** 线程回调
    */
    virtual void ThreadCallBack()
    {
        while (1)
        {

            {
                std::lock_guard<std::recursive_mutex> lock(m_mutex);

                if (m_stop)
                {
                    break;
                }
            }
		
            // 取出队首
            {
                std::lock_guard<std::recursive_mutex> lock(m_mutex);

                if (m_taskQue.empty())
                {
                    ::Sleep(0);
                    continue;
                }

                m_currentTask = m_taskQue.front();
                m_taskQue.pop();

                if (m_currentTask == nullptr)
                {
                    ::Sleep(0);
                    continue;
                }
            }
            
            m_currentTask->DoTask();
			

            // 准备销毁
            std::shared_ptr<ITask> tmp = m_currentTask;

            {
                std::lock_guard<std::recursive_mutex> lock(m_mutex);
                m_currentTask = nullptr;
            }
            
        }
    }

private:

    /** 互斥量
    */
    std::recursive_mutex m_mutex;
	
    /** 线程
    */
    std::thread* m_pThread;

    /** 任务队列
    */
    std::queue<std::shared_ptr<ITask> > m_taskQue;
	
	/** 是否停止了
    */
    bool m_stop;

    /** 当前正在执行的
    */
    std::shared_ptr<ITask> m_currentTask;
};

需要注意的是：

// 准备销毁
std::shared_ptr<ITask> tmp = m_currentTask;

{
    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    m_currentTask = nullptr;
}

智能指针的置空也需要加锁，如果没有std::shared_ptr<ITask> tmp = m_currentTask;会导致内存泄露。

4、事件event

windows中有现成的事件，但是C11没有，上文有说过event有点像生产者消费者模型，C11中的条件变量也很想生产者消费者，所以可以自己实现一个简单事件：

/** 简单事件
@note 不提供析构函数，如果当该类析构的时候，但是还处于Wait() 状态，很不幸的告诉你发生未定义行为
*/
class SimpleEvent :
    public NonCopyable
{
public:
    /** 等待一个信号
    */
    void Wait()
    {
        std::unique_lock<std::mutex> lck(m_mutex);

        if (!m_hasSignal)
        {
            // 不会死锁，考虑：
            // 1、m_mutex.unlock();
            // 2、wait()
            // 3、m_mutex.lock();
            // wait(lck) 相当于将1、2两步放到一个cpu周期内
            m_con.wait(lck);
        }

        m_hasSignal = false;
    }

    /** 设置一个信号
    */
    void SetEvent()
    {
        std::unique_lock<std::mutex> lck(m_mutex);
        m_hasSignal = true;
        m_con.notify_all();
    }

private:
    /** 互斥量
    */
    std::mutex m_mutex;

    /** condition_variable
    */
    std::condition_variable m_con;

    /** 是否有信号，只是记录是否有信号，但是不记录信号次数
    @note 主要是为了先调用SetEvent()，然后调用wait的情况。考虑在Wait()前加上::Sleep(1000);
    */
    bool m_hasSignal = false;
};

将m_hasSignal 改为int计数将会是一个好用的事件，但是对于任务队列来说，会让队列空转,所以这里使用bool类型标记一下即可。加入event后的代码：

/** 前置声明，简单事件，只SimpleTaskQueue用
*/
class SimpleEvent;

/** 简单线程任务模型
@note 有点像生产者消费者模型，只是消费者只有一个
*/
class SimpleTaskQueue :
    public NonCopyable
{
public:
    /** 构造函数
    */
    SimpleTaskQueue();

    /** 析构函数
    */
    ~SimpleTaskQueue();

public:
    /** 开始循环
    @return 是否成功
    */
    bool Start();

    /** 停止所有任务
    */
    void StopAll();

    /** 停止当前的任务
    */
    void StopCurrent();

    /** 清空所有任务包括当前的，但不停止循环
    */
    void ClearAll();

    /** 清空所有任务不包括当前的，但不停止循环
    */
    void ClearQueue();

    /** 添加一个任务
    @param [in] task 任务
    */
    void PushTask(const std::shared_ptr<ITask>& task);

    /** 添加一个函数任务
    @param [in] task 任务
    */
    void PushTask(const std::function<void()>& task);

public:
    /** 线程回调
    */
    virtual void ThreadCallBack();

private:
    /** 线程
    */
    std::thread* m_pThread;

    /** 互斥量
    */
    std::recursive_mutex m_mutex;

    /** 线程事件
    */
    std::shared_ptr<SimpleEvent> m_spEvent;

    /** 任务队列
    */
    std::queue<std::shared_ptr<ITask> > m_taskQue;

    /** 是否停止了
    */
    bool m_stop;

    /** 当前正在执行的
    */
    std::shared_ptr<ITask> m_currentTask;
};

#include "SimpleTaskQueue.h"

/** 简单事件
@note 不提供析构函数，如果当该类析构的时候，但是还处于Wait() 状态，很不幸的告诉你发生未定义行为
*/
class SimpleEvent :
    public NonCopyable
{
public:
    /** 等待一个信号
    */
    void Wait()
    {
        std::unique_lock<std::mutex> lck(m_mutex);

        if (!m_hasSignal)
        {
            // 不会死锁，考虑：
            // 1、m_mutex.unlock();
            // 2、wait()
            // 3、m_mutex.lock();
            // wait(lck) 相当于将1、2两步放到一个cpu周期内
            m_con.wait(lck);
        }

        m_hasSignal = false;
    }

    /** 设置一个信号
    */
    void SetEvent()
    {
        std::unique_lock<std::mutex> lck(m_mutex);
        m_hasSignal = true;
        m_con.notify_all();
    }

private:
    /** 互斥量
    */
    std::mutex m_mutex;

    /** condition_variable
    */
    std::condition_variable m_con;

    /** 是否有信号，只是记录是否有信号，但是不记录信号次数
    @note 主要是为了先调用SetEvent()，然后调用wait的情况。考虑在Wait()前加上::Sleep(1000);
    */
    bool m_hasSignal = false;
};

SimpleTaskQueue::SimpleTaskQueue() :
    m_stop(false),
    m_pThread(nullptr)
{
}

SimpleTaskQueue::~SimpleTaskQueue()
{
    if (m_pThread != nullptr)
    {
        StopAll();
        m_pThread->join();
        delete m_pThread;
        m_pThread = nullptr;
    }
}

bool SimpleTaskQueue::Start()
{
    m_spEvent.reset(new(std::nothrow) SimpleEvent());
    m_pThread = new (std::nothrow) std::thread(&SimpleTaskQueue::ThreadCallBack, this);
    return (m_pThread != NULL) & (m_spEvent != NULL);
}

void SimpleTaskQueue::StopAll()
{
    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    ClearAll();
    m_stop = true;
    m_spEvent->SetEvent();
}

void SimpleTaskQueue::StopCurrent()
{
    std::lock_guard<std::recursive_mutex> lock(m_mutex);

    if (m_currentTask != nullptr)
    {
        m_currentTask->Stop();
    }
}

void SimpleTaskQueue::ClearAll()
{
    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    StopCurrent();
    ClearQueue();
}

void SimpleTaskQueue::ClearQueue()
{
    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    std::queue<std::shared_ptr<ITask> > tmp = std::queue<std::shared_ptr<ITask> >();
    m_taskQue.swap(tmp);
}

void SimpleTaskQueue::PushTask(const std::shared_ptr<ITask>& task)
{
    std::lock_guard<std::recursive_mutex> lock(m_mutex);
    m_taskQue.push(task);
    m_spEvent->SetEvent();
}

void SimpleTaskQueue::PushTask(const std::function<void()>& task)
{
    PushTask(std::shared_ptr<ITask>(new SimpleFunTask(task)));
}

void SimpleTaskQueue::ThreadCallBack()
{
    while (true)
    {
        {
            std::lock_guard<std::recursive_mutex> lock(m_mutex);

            if (m_stop)
            {
                break;
            }
        }

        m_spEvent->Wait();

        // 将队列里的全部执行掉
        while (true)
        {
            // 取出队首
            {
                std::lock_guard<std::recursive_mutex> lock(m_mutex);

                if (m_taskQue.empty())
                {
                    break;
                }

                m_currentTask = m_taskQue.front();
                m_taskQue.pop();

                if (m_currentTask == nullptr)
                {
                    continue;
                }
            }

            // 执行任务
            m_currentTask->DoTask();

            // 准备销毁
            std::shared_ptr<ITask> tmp = m_currentTask;

            {
                std::lock_guard<std::recursive_mutex> lock(m_mutex);
                m_currentTask = nullptr;
            }
        }
    }
}

使用示例代码：

    void Test_taskQue1()
    {
        SimpleTaskQueue simpleTaskQue;
        simpleTaskQue.Start();

        bool ret = false;
        int t1 = 0;
        int t2 = 0;

        simpleTaskQue.PushTask([&]()
        {
            t1 = 1;
            t2 = 2;
            ret = true;
        });

        while (true)
        {
            ::Sleep(1);
        }
    }

有意思的是

 simpleTaskQue.PushTask([&]()
 {
      t1 = 1;
      t2 = 2;
      ret = true;
 });

可以直接的将lambda中的代码放到线程中执行，非常方便。

代码链接：ddm/ddm/src/thread/task at main · yunate/ddm (github.com)

5、总结

本文介绍了一个简单任务队列，下文会介绍基于任务队列的一个应用：简单日志

我叫侯万楼
关注
  • 9
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
taskqueue:使用线程池并行完成任务的任务队列
07-13
任务队列 TaskQueue 是一个只有头文件的库，用于与使用 Boost 构建的并行执行任务。 如何使用它 要使用它，您需要做的就是将复制到您的源代码树并链接到 Boost 线程和 asio 库。 没有文档，只有一个工作示例，用于计算使用机器上所有可用内核来反转散列密码的蛮力查找表。 这里有一个简短的片段作为示例......但请查看。 // Creates a task queue with a pool of 4 worker threads TaskQueue<HashStringTask> queue ( 4 ); // Add task to the work queue... A call may block until there is an available thread in the pool to accept the task. queue.QueueTas
c语言线程任务队列,进程、线程、任务、队列
weixin_42346710的博客
05-22 919
一、 进程1.进程是操作系统分配资源的基本单元,是一个具有一定独立功能的程序关于某次数据集合的一次运行活动.2.进程是指在系统中正在运行的一个应用程序，就是一段程序的执行过程,我们可以理解为手机上的一个app.3.每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内，拥有独立运行所需的全部资源二、 线程1.线程是程序执行流的最小单元，是进程中的一个实体.2.一个进程要想执行任务,必须至...
c++实现一个高并发服务器（一）任务队列
SWELER的博客
12-13 693
这是一个基于线程池+Epoll的IO多路复用、非阻塞IO技术，的高并发服务器框架。
C++设计模式 任务队列与单例模式
qq_60420877的博客
08-31 149
如果一个对象被频繁地创建和销毁，但每次都提供相同的功能，那么这种资源消耗是没有意义的。使用单例模式的懒汉式初始化，对象只有在第一次被需要时才会被创建。如果多个实例可能会导致不一致的结果或状态冲突，那么确保一个类只有一个实例可能是有意义的。使用单例模式，您可以在一个地方管理这种全局状态，而不是将状态散布在多个对象中。任务队列是一种常用的并发设计模式，用于将多个任务放入一个队列，然后由一个或多个工作线程来执行这些任务。下一章我们再介绍C++中单例模式的实现方法懒汉式、饿汉式、线程安全的懒汉式单例模式的创建。
C++ 实现线程安全的任务队列
热门推荐
flyfish
03-06 1万+
C++ 实现线程安全的任务队列 flyfish 2015-3-6 一、三个接口函数说明 1 add 新增任务 2 get_nonblocking 非阻塞获取任务或者空任务 3 get_blocking 阻塞获取任务 头文件 #pragma once #include #include #include #include //任务 网络发送任务使用的结构，通常有...
C++ 简单的任务队列详解
12-31
任务队列是指能够实现任务在多线程间安全传递的先入先出的队列。 任务是指组合了数据和操作的对象，这里面定义为CTask类的对象。 任务的实现： Task.cpp #include stdafx.h #include Task.h #include <iostream> using namespace std; CTask::CTask(int* nCount) { m_nCount = nCount; } CTask::~CTask() { } void CTask::DoWork() { (*m_nCount)++; cout << Count = << *m_n
C++任务队列与多线程
weixin_33984032的博客
01-14 447
摘要：       很多场合之所以使用C++，一方面是由于C++编译后的native code的高效性能，另一方面是由于C++优秀的并发能力。并行方式有多进程 和多线程之分，本章暂且只讨论多线程，多进程方面的知识会在其他章节具体讨论。多线程是开发C++服务器程序非常重要的基础，如何根据需求具体的设计、分配线程以及线程间的通信，也是服务器程序非常重要的部分，除了能够带来程序的性能提高外，若设计失误...
用标准C++实现任务队列
xungen的博客
11-22 5356
下面介绍一个简单的任务队列，查看完整代码。 在实现任务队列前需要定义一个接口与一个工具类 任务接口：子类实现接口的run方法来处理具体任务。 自旋锁类：用于保护任务队列的并发访问（用C++11原子操作实现）。 任务接口源码如下 //任务接口 class WorkItem { public: //接口方法必须在子类实现 virtual void run() = 0; public: ...
C++ 简单的任务队列实例
09-02
C++ 简单的任务队列
C++ 简单的任务队列
weixin_30329623的博客
09-02 278
任务队列是指能够实现任务在多线程间安全传递的先入先出的队列。 任务是指组合了数据和操作的对象，这里面定义为CTask类的对象。 任务的实现： Task.cpp 1 #include "stdafx.h" 2 #include "Task.h" 3 #include <iostream> 4 using namespace std; 5 6 ...
C++多线程，消息队列用法
12-03
C++多线程，消息队列用法，为了凑够20个字，拼了。
SafeQueue:C++ 中的线程安全队列实现
05-30
安全队列 这个类是一个多生产者、多消费者队列。 它同时提供阻塞和非阻塞消费，而生产总是阻塞。 容量是动态调整的。 实现基于std::queue ，使用std::mutex和std::condition_variable实现线程安全。 可以使用右值引用调用Produce(T&& item)函数。 Consume(T& item)函数立即返回一个布尔值，表示成功。 ConsumeSync(T& item)方法将阻塞调用线程，直到它可以从队列中取出一个项目。 Finish方法停止所有等待的消费者 (ConsumeSync)，并使它们返回 false。 例子 制作人： SafeQueue<MyType> queue; // insert elements queue.Produce(std::move(var1)); queue.Produce(std::move(var2)); 非阻塞消费
C++线程安全队列_示例代码.zip
01-16
【C++ 语言】线程安全队列 ( 条件变量 | 线程调度 ) : https://hanshuliang.blog.csdn.net/article/details/102851323 下载完项目后 , 使用 Visual Studio 打开 , 注意需要配置 POSIX 线程库 ( 参考以下博客配置环境运行 ) ; 【Visual Studio】Visual Studio 2019 社区版 CMakeList 开发环境安装 ( 下载 | 安装相关组件 | 创建编译执行项目 | 错误处理 ) 【Visual Studio 2019】创建 导入 CMake 项目 【C++ 语言】Visual Studio 配置 POSIX 线程 ( Windows 不支持 POSIX | 配置文件下载 | 库文件说明 | 配置过程 )
多线程任务队列
12-27
简单的多线程任务队列
C++多线程队列
05-18
构造一个队列，并完成入队列和出队列的函数，要求该队列支持多线程 (即一个线程做入队列操作而另一个线程做出队列操作而且两个线程必须同时运行)
C++实现线程安全队列
05-14
使用互斥变量技术完成C++安全队列，同时编写测试代码进行此队列的测试。
线程池 工作队列 C++ work Queue 示例
06-01
windows 线程池demo，示例，简单明了，适用范围广，容易上手使用，实现了最基本的线程池
分布式系统.pptx
最新发布
04-29
分布式系统.pptx
c++ 线程安全队列 代码
04-07
以下是一个简单的线程安全队列的代码实现： ``` #include <queue> #include <mutex> #include <condition_variable> template<typename T> class ThreadSafeQueue { public: ThreadSafeQueue() {} void push(const T& value) { std::lock_guard<std::mutex> lock(mutex_); queue_.push(value); condition_.notify_one(); } bool try_pop(T& value) { std::lock_guard<std::mutex> lock(mutex_); if (queue_.empty()) { return false; } value = queue_.front(); queue_.pop(); return true; } void wait_and_pop(T& value) { std::unique_lock<std::mutex> lock(mutex_); condition_.wait(lock, [this](){ return !queue_.empty(); }); value = queue_.front(); queue_.pop(); } bool empty() const { std::lock_guard<std::mutex> lock(mutex_); return queue_.empty(); } private: mutable std::mutex mutex_; std::queue<T> queue_; std::condition_variable condition_; }; ``` 这个类使用了一个 `std::queue` 作为内部存储，使用 `std::mutex` 和 `std::condition_variable` 来实现线程安全。其中，`push` 函数将元素加到队列末尾，并通过 `notify_one` 通知正在等待 `pop` 的线程；`try_pop` 函数尝试从队列头部取出元素，如果队列为空则返回 `false`；`wait_and_pop` 函数会等待队列非空，然后再取出队列头部的元素；`empty` 函数用来判断队列是否为空。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值