c++回调函数、同步队列、生产者消费者举例

最新推荐文章于 2022-11-16 18:37:38 发布
最新推荐文章于 2022-11-16 18:37:38 发布
阅读量2.5k 收藏 4
点赞数 2
文章标签： 参考代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29022265/article/details/108286345
版权

C++11 同步队列、注册回调函数、生产者消费者代码记录

同步队列：
// data queue
template <typename T>
class SynchronizedQueue {
public:
    SynchronizedQueue()
        : queue_()
        , mutex_()
        , cond_()
        , request_to_end_(false)
        , enqueue_data_(true)
    {
    }

    void enqueue(const T& data)
    {
        std::unique_lock<std::mutex> lock(mutex_);

        if (enqueue_data_)
        {
            queue_.push(data);
            cond_.notify_one();
        }
    }

    bool dequeue(T& result)
    {
        std::unique_lock<std::mutex> lock(mutex_);

        while (queue_.empty() && (!request_to_end_))
        {
            cond_.wait(lock);
        }

        if (request_to_end_)
        {
            doEndActions();
            return false;
        }

        result = queue_.front();
        queue_.pop();

        return true;
    }

    void stopQueue()
    {
        std::unique_lock<std::mutex> lock(mutex_);
        request_to_end_ = true;
        cond_.notify_one();
    }

    unsigned int size()
    {
        std::unique_lock<std::mutex> lock(mutex_);
        return static_cast<unsigned int>(queue_.size());
    }

    bool isEmpty() const
    {
        std::unique_lock<std::mutex> lock(mutex_);
        return (queue_.empty());
    }

private:
    void doEndActions()
    {
        enqueue_data_ = false;

        while (!queue_.empty())
        {
            queue_.pop();
        }
    }

    std::queue<T> queue_;            // Use STL queue to store data
    mutable std::mutex mutex_;     // The mutex to synchronise on
    std::condition_variable cond_; // The condition to wait for

    bool request_to_end_;
    bool enqueue_data_;
};
Task基类：
// task base
class BaseTask {
public:

    using PrintFunc = std::function<void(int level, std::string& msg)>;

    BaseTask() = default;
    virtual ~BaseTask() = default;
    virtual void Start() {}
    virtual void Stop() {}

    virtual void RegisterPrint(PrintFunc cb) {
        print_ = cb;
    }
protected:

    volatile bool stop_flag_ = false;

    std::shared_ptr<std::thread> worker_ = nullptr;
    virtual void Process(std::string name) {}
    virtual void Print(int level, std::string msg) {
        if (this->print_)
            this->print_(0, msg);
    }

    PrintFunc print_ = nullptr;

};
Task派生类，生产者
// producer
template <typename T>
class Producer :public BaseTask {
public:

    using DataCallBack = std::function<void(T&)>;

    Producer() {}
    virtual ~Producer() override { this->Stop(); }
    Producer(const Producer & r) = default;
    Producer &operator=(const Producer &r) = default;

    virtual void Start() override {
        if (worker_)
            return;
        else {
            worker_.reset(new std::thread(std::bind(&Producer::Process, this, std::string("Producer thread"))));
        }
    }

    virtual void Stop() override {
        if (!worker_)
            return;

        stop_flag_ = true;
        worker_->join();
        worker_.reset();
        stop_flag_ = false;
    }

    void RegisterDataCallback(DataCallBack cb) { cb_ = cb; }

protected:
    virtual void Process(std::string name) override {

        int i = 0;
        while (!stop_flag_) {
            // sleep
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));

            // product
            T data = i++;
            if (cb_) cb_(data);
            
            // time string
            const int buffer_len = 128;
            time_t t = time(0);
            struct tm* now = localtime(&t);
            char buffer[buffer_len];
            strftime(buffer, buffer_len, "%Y-%m-%d_%H_%M_%S", now);
            Print(0, name + std::string(", ") + std::string(buffer) + std::string(": ") + std::to_string(data));
        }
    }

private:

    DataCallBack cb_ = nullptr;

};
Task派生类，消费者
// consumer
template <typename T>
class Consumer:public BaseTask {
public:

    Consumer(): datas_(new SynchronizedQueue<T>), producer_(new Producer<T>){}
    virtual ~Consumer() override { this->Stop(); }
    Consumer(const Consumer & r) = default;
    Consumer &operator=(const Consumer &r) = default;

    virtual void Start() override {
        if (worker_)
            return;
        else {
            producer_->RegisterDataCallback(std::bind(&Consumer::DataCallback, this, std::placeholders::_1));
            producer_->Start();
            worker_.reset(new std::thread(std::bind(&Consumer::Process, this, std::string("Worker thread"))));
        }
    }

    virtual void Stop() override {
        if (!worker_)
            return;

        producer_->Stop();

        stop_flag_ = true;
        worker_->join();
        worker_.reset();
        stop_flag_ = false;
    }

    virtual void RegisterPrint(PrintFunc cb) override {
        print_ = cb;
        this->producer_->RegisterPrint(cb);
    }

protected:
    virtual void Process(std::string name) override {
        while (!stop_flag_) {
            // sleep
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));

            //consume
            T data;
            this->datas_->dequeue(data);

            // time string
            const int buffer_len = 128;
            time_t t = time(0);
            struct tm* now = localtime(&t);
            char buffer[buffer_len];
            strftime(buffer, buffer_len, "%Y-%m-%d_%H_%M_%S", now);
            Print(0, name + std::string(", ") + std::string(buffer) + std::string(": ") + std::to_string(data));
        }
    }

    void DataCallback(T& data) {
        if (datas_)
            datas_->enqueue(data);
    }


private:

    std::shared_ptr<SynchronizedQueue<T>> datas_ = nullptr;
    std::shared_ptr<Producer<T> > producer_ = nullptr;
    volatile bool stop_flag_ = false;

};
测试函数
//test
int main(int argc, char** argv)
{
    Notify notify;
    Consumer<int> consumer_;
    consumer_.RegisterPrint(std::bind(&Notify::Print, &notify, std::placeholders::_1, std::placeholders::_2));
    consumer_.Start();
    while (1) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
    return 0;
}
全部代码
#include <memory>
#include <iostream>
#include <thread>
#include <queue>
#include <string>
#include <mutex>
#include <functional>
#include <condition_variable>


// used for print function
class Notify {
public:
    Notify() {}
    ~Notify() {}
    Notify(const Notify & r) = default;
    Notify &operator=(const Notify &rhs) = default;

    void Print(int level, std::string& msg) {
        switch (level) {
        case 0:
            std::cout << msg << std::endl;
            break;
        case 1:
        default:
            std::cerr << msg << std::endl;
        }
    }
};

// data queue
template <typename T>
class SynchronizedQueue {
public:
    SynchronizedQueue()
        : queue_()
        , mutex_()
        , cond_()
        , request_to_end_(false)
        , enqueue_data_(true)
    {
    }

    void enqueue(const T& data)
    {
        std::unique_lock<std::mutex> lock(mutex_);

        if (enqueue_data_)
        {
            queue_.push(data);
            cond_.notify_one();
        }
    }

    bool dequeue(T& result)
    {
        std::unique_lock<std::mutex> lock(mutex_);

        while (queue_.empty() && (!request_to_end_))
        {
            cond_.wait(lock);
        }

        if (request_to_end_)
        {
            doEndActions();
            return false;
        }

        result = queue_.front();
        queue_.pop();

        return true;
    }

    void stopQueue()
    {
        std::unique_lock<std::mutex> lock(mutex_);
        request_to_end_ = true;
        cond_.notify_one();
    }

    unsigned int size()
    {
        std::unique_lock<std::mutex> lock(mutex_);
        return static_cast<unsigned int>(queue_.size());
    }

    bool isEmpty() const
    {
        std::unique_lock<std::mutex> lock(mutex_);
        return (queue_.empty());
    }

private:
    void doEndActions()
    {
        enqueue_data_ = false;

        while (!queue_.empty())
        {
            queue_.pop();
        }
    }

    std::queue<T> queue_;            // Use STL queue to store data
    mutable std::mutex mutex_;     // The mutex to synchronise on
    std::condition_variable cond_; // The condition to wait for

    bool request_to_end_;
    bool enqueue_data_;
};

// task base
class BaseTask {
public:

    using PrintFunc = std::function<void(int level, std::string& msg)>;

    BaseTask() = default;
    virtual ~BaseTask() = default;
    virtual void Start() {}
    virtual void Stop() {}

    virtual void RegisterPrint(PrintFunc cb) {
        print_ = cb;
    }
protected:

    volatile bool stop_flag_ = false;

    std::shared_ptr<std::thread> worker_ = nullptr;
    virtual void Process(std::string name) {}
    virtual void Print(int level, std::string msg) {
        if (this->print_)
            this->print_(0, msg);
    }

    PrintFunc print_ = nullptr;

};

// producer
template <typename T>
class Producer :public BaseTask {
public:

    using DataCallBack = std::function<void(T&)>;

    Producer() {}
    virtual ~Producer() override { this->Stop(); }
    Producer(const Producer & r) = default;
    Producer &operator=(const Producer &r) = default;

    virtual void Start() override {
        if (worker_)
            return;
        else {
            worker_.reset(new std::thread(std::bind(&Producer::Process, this, std::string("Producer thread"))));
        }
    }

    virtual void Stop() override {
        if (!worker_)
            return;

        stop_flag_ = true;
        worker_->join();
        worker_.reset();
        stop_flag_ = false;
    }

    void RegisterDataCallback(DataCallBack cb) { cb_ = cb; }

protected:
    virtual void Process(std::string name) override {

        int i = 0;
        while (!stop_flag_) {
            // sleep
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));

            // product
            T data = i++;
            if (cb_) cb_(data);
            
            // time string
            const int buffer_len = 128;
            time_t t = time(0);
            struct tm* now = localtime(&t);
            char buffer[buffer_len];
            strftime(buffer, buffer_len, "%Y-%m-%d_%H_%M_%S", now);
            Print(0, name + std::string(", ") + std::string(buffer) + std::string(": ") + std::to_string(data));
        }
    }

private:

    DataCallBack cb_ = nullptr;

};

// consumer
template <typename T>
class Consumer:public BaseTask {
public:

    Consumer(): datas_(new SynchronizedQueue<T>), producer_(new Producer<T>){}
    virtual ~Consumer() override { this->Stop(); }
    Consumer(const Consumer & r) = default;
    Consumer &operator=(const Consumer &r) = default;

    virtual void Start() override {
        if (worker_)
            return;
        else {
            producer_->RegisterDataCallback(std::bind(&Consumer::DataCallback, this, std::placeholders::_1));
            producer_->Start();
            worker_.reset(new std::thread(std::bind(&Consumer::Process, this, std::string("Worker thread"))));
        }
    }

    virtual void Stop() override {
        if (!worker_)
            return;

        producer_->Stop();

        stop_flag_ = true;
        worker_->join();
        worker_.reset();
        stop_flag_ = false;
    }

    virtual void RegisterPrint(PrintFunc cb) override {
        print_ = cb;
        this->producer_->RegisterPrint(cb);
    }

protected:
    virtual void Process(std::string name) override {
        while (!stop_flag_) {
            // sleep
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));

            //consume
            T data;
            this->datas_->dequeue(data);

            // time string
            const int buffer_len = 128;
            time_t t = time(0);
            struct tm* now = localtime(&t);
            char buffer[buffer_len];
            strftime(buffer, buffer_len, "%Y-%m-%d_%H_%M_%S", now);
            Print(0, name + std::string(", ") + std::string(buffer) + std::string(": ") + std::to_string(data));
        }
    }

    void DataCallback(T& data) {
        if (datas_)
            datas_->enqueue(data);
    }


private:

    std::shared_ptr<SynchronizedQueue<T>> datas_ = nullptr;
    std::shared_ptr<Producer<T> > producer_ = nullptr;
    volatile bool stop_flag_ = false;

};

//test
int main(int argc, char** argv)
{
    Notify notify;
    Consumer<int> consumer_;
    consumer_.RegisterPrint(std::bind(&Notify::Print, &notify, std::placeholders::_1, std::placeholders::_2));
    consumer_.Start();
    while (1) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
    return 0;
}
CmakeLists文件
cmake_minimum_required(VERSION 3.0)

set(DEMO_NAME producer_consumer)
add_executable(${DEMO_NAME} producer_consumer.cpp)

set(MAJOR_VERSION "0")
set(MINOR_VERSION "0")
set(PATCH_VERSION "0")
set(VERSION_STRING "${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11  -pthread" )

target_compile_options(${DEMO_NAME}
        PRIVATE $<$<CXX_COMPILER_ID:GNU>:-Wall -Werror -Wno-c++11-long-long>
        PRIVATE $<$<CXX_COMPILER_ID:AppleClang>:-Wno-unknown-pragmas -Wall -Werror -Wno-c++11-long-long>
        PRIVATE $<$<CXX_COMPILER_ID:Clang>:-Wno-unknown-pragmas -Wall -Werror -Wno-c++11-long-long>)
非科班CPP程序员
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux下C/C++程序处理Ctrl+C的例子
THU_WM的专栏
11-17 8130
遇到一个场景：程序要读入文件
捕捉ctrl+c信号，并进行操作（C++实现）
RookieWantToFly的博客
10-14 2341
使用sigaction函数，绑定信号处理器函数 #include <stdio.h> #include <signal.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <stdint.h> void exit_handler(int signo); uint8_t InitSystem(){ printf("initSyst.
C++ 处理 Kill 信号、Ctrl+C信号
yaxf999的专栏
04-06 1万+
来自： http://blog.csdn.net/xian0617/article/details/6689357/* * WaitQuitSignal.h * *  Created on: Aug 14, 2011 *      Author: xian0617 */    #ifndef WAITQUITSIGNAL_H_  #define WAITQUITSIGNAL_H_
【C++】C++函数捕获Ctrl+C方法
guanlizhongxintishi的博客
08-26 1690
我们在UNIX的系统上，用CTRL+C表示退出当前进程，在这种退出当前进程的情况下，调用某个服务进程。2）然后再增加如下的方法来写捕获到CTRL+C后要执行的内容。1）在当前需要加捕获的地方，增加如下代码。...
linux c++ 进程间信号的发送与接收
dasgk的专栏
07-16 2458
信号不仅可以用于事件的异步处理，同时也可以用作数据传输
C++回调函数例子，供初学者使用
08-02
通过Qt控制台工程写了几个回调函数的例子，希望对初学者有帮助
C++中回调函数(CallBack)的用法分析
01-20
本文实例分析了C++中回调函数(CallBack)的用法。分享给大家供大家参考。具体分析如下： 如果试图直接使用C++的成员函数作为回调函数将发生错误，甚至编译就不能通过。 其错误是普通的C++成员函数都隐含了一个传递...
C++ 中回调函数详解及简单实例
08-30
C++ 中回调函数详解及简单实例 在 C++ 编程中，回调函数是一个非常重要的概念，它允许程序员在程序执行中插入自定义的函数，以便于扩展程序的功能。今天，我们将详细介绍 C++ 中回调函数的详解及简单实例。 什么是...
C/C++回调函数介绍
01-01
对于很多初学者来说，往往觉得回调函数很神秘，很想知道回调函数的工作原理。本文将要解释什么是回调函数、它们有什么好处、为什么要使用它们等等问题，在开始之前，假设你已经熟知了函数指针。 什么是回调函数？ ...
C++函数指针和回调函数使用解析
01-20
函数指针 函数指针是指向函数的指针变量。 通常我们说的指针变量是指向一个整型变、字符型或数组等变量，而函数指针是指向函数。 函数指针可以像一般函数一样，用于调用函数、传递参数。 函数指针变量的声明： ...
C++中cin输入过程中如何处理ctrl+c输入
Tomhex的博客
11-16 1231
c++中处理ctrl+c造成的异常
ROS 使用signal 终止 Node
haha074的博客
10-09 3436
在终端中使用ctrl+c可以强制终止运行的程序，但有时需要在终止时作一些处理（如ros::shotdown,free等），可使用信号函数作退出处理   头文件 #include"csignal" 信号处理函数 void signalHandler(int signum) { ROS_INFO("%s is received, Terminating the node...",st...
ros操作笔记
weixin_41602564的博客
09-03 1000
通过rosparam set [参数名] [参数值] 可以设置参数值； 通过rosparam get [参数名] 可以查看参数值； rosparam list
多线程实现生产者和消费者（同步队列）以及线程异步操作async
Clement
07-16 1310
传统的生产者消费者模型 生产者-消费者模式是一个十分经典的多线程并发协作的模式，弄懂生产者-消费者问题能够让我们对并发编程的理解加深。所谓生产者-消费者问题，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据，为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；而消费者只需要从共享数据区中去获取数据，就不再需要关心生产者的行为。但是，这个共享数据区域中应该具备这样的线程间并发协作的功
C++处理Ctrl+C中断信号
机器人们的后勤仓库
01-12 1万+
#include <iostream> #include <csignal>using namespace std;static volatile int keepRunning = 1; void sig_handler( int sig ) { if ( sig == SIGINT) { keepRunning = 0; } }int main( ) {
C++11 同步阻塞队列
热门推荐
djqueen的博客
07-17 1万+
参考《深入应用C++11》 SyncQueue.cpp //同步阻塞队列 #include "SyncQueue.h" using namespace std; template<class T> SyncQueue<T>::SyncQueue(int max_size):max_size(max_size)//这里注意类不能少了类型SyncQueue<T&...
C++同步队列
NB_vol_1的专栏
08-19 1177
本文实现了一个带锁同步队列，可以让多个线程向队列里读写数据而不会产生异常，很方便的应用于生产者消费者模式的程序中 同步队列没什么难的，无非就是读写的时候加锁，并且写入的时候通知消费者。稍微复杂的地方在于怎么样让生产者消费者停止运行，或者说，怎么才能让同步队列退出；因为一般的应用不可能无限运行下去，它总有停止的时候，当应用程序退出的时候，我们需要告诉生产者和消费者这个消息。我的做法是这样的，...
C++ folly库解读（三）Synchronized —— 比std::lock_guard/std::unique_lock更易用、功能更强大的同步机制
weixin_48967543的博客
06-19 647
目录返利 www.cpa5.cn 传统同步方案的缺点 folly/Synchronized.h 简单使用 Synchronized的模板参数 withLock()/withRLock()/withWLock() —— 更易用的加锁方式 升级锁 ulock()和 withULockPtr() Timed Locking Synchronized 与 std::condition_variable acquireLocked() —— 同时锁多个数据 使用一把锁，锁多个数据 struct std::tuple.
synchronized 底层原理
u011196623的专栏
12-20 182
1、定义一个synchronized修饰的同步代码块 public class SyncTest { public int i; public void syncTask(){ //同步代码库 synchronized (this){...
c++ 生产者消费者队列
最新发布
09-25
c生产者消费者队列是一种解决多线程编程中生产者和消费者之间协作的制。它通过一个共享的队列来实现生产者将数据放...生产者线程通过调用Put函数将数据放入队列，消费者线程通过调用Get函数从队列中取出数据进行消费。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值