C++ 11实现 messagequeue, looper,handler

最新推荐文章于 2024-04-02 15:17:02 发布
最新推荐文章于 2024-04-02 15:17:02 发布
阅读量1.7k 收藏 6
点赞数 1
分类专栏： C/C++ 文章标签： c++11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/suixin______/article/details/117785821
版权
本文介绍了一个基于C++实现的消息队列和调度器的设计方案，包括Message、MessageQueue和Dispatcher等关键类的定义与功能实现，适用于多线程环境下的任务调度与消息传递。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

 

Message.h 可根据实际情况定义

#pragma once

#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <functional>

class Dispatcher;
using std::string;

class Message: public std::enable_shared_from_this<Message> {
 friend class Dispatcher;
 private:
   int m_h;
   string get_message_name();

 public:
  virtual ~Message() = 0;
  string to_string();

  Message(const Message &) = delete;
  Message &operator=(const Message &) = delete;
  Message() = delete;

  virtual bool isSameMessage(std::shared_ptr<Message> msg);

  void set_next_hop(Dispatcher* dispatcher) {
    m_next_hop = dispatcher;
  }

  Dispatcher* get_next_hop() {
    return m_next_hop;
  }

 protected:
  string mName;
  Dispatcher* m_next_hop;
};

inline string Message::get_message_name() { return mName; }
inline string Message::to_string() { return get_message_name(); }

looper是一个thread+一个Messagequeue

MyLooper.h

#pragma once
#ifndef _MY_LOOPER_H__
#define _MY_LOOPER_H__

#include <thread>

#include <shared_mutex>
#include "Message.h"
#include "MessageQueue.h"

class Dispatcher;

class MyLooper {
 protected:
  string mName;
  Dispatcher *mDispatcher;
  std::unique_ptr<MessageQueue> mMessageQueue;
  std::thread* mLooperThread;

 public:
  static constexpr bool FEATURE_DYNAMIC_THREAD = false;
  std::shared_timed_mutex looperMutex;
  std::condition_variable_any looperCv;
  bool isLooperReady;
  bool mExit;
  bool mReleaseThread;

  MyLooper();
  virtual ~MyLooper();

  void init(Dispatcher *dispatcher);
  void dispatch(std::shared_ptr<Message> msg);
  void dispatchSync(std::shared_ptr<Message> msg);
  void handleMessage(std::shared_ptr<Message> msg);
  void handleMessageSync(std::shared_ptr<Message> msg);

  size_t getSize();
  bool isEmptyQueue();
  void dumpMessageQueue();
  std::shared_ptr<Message> getFirstMessage();

  std::thread *getLooperThread();
  void acquireThread();
  void releaseThread();
  string to_string();

  void waitForLooperToConsumeAllMsgs();
  void killLooper();
};

inline MyLooper::MyLooper(){
    mExit = false;
    mLooperThread = nullptr;
    mMessageQueue = std::unique_ptr<MessageQueue>(new MessageQueue);
};

inline MyLooper::~MyLooper() {
  if (mMessageQueue) {
    mMessageQueue->clear();
  }
  killLooper();
  if (mLooperThread != nullptr) {
    mLooperThread->join();
    delete mLooperThread;
    mLooperThread = nullptr;
  }
  mMessageQueue = nullptr;
};

inline std::thread *MyLooper::getLooperThread() { return mLooperThread; }
inline string MyLooper::to_string() { return mName; }
#endif

MyLooper.cpp 


#include <thread>
#include <chrono>
#include "MyLooper.h"
#include "Dispatcher.h"


using std::condition_variable_any;
using std::lock_guard;
using std::unique_lock;
using std::thread;
using std::runtime_error;

void myLoop(MyLooper *instance) {
  string TAG = instance->to_string();
  //setThreadName(TAG.c_str());
  while (!instance->mExit) {
    {
      std::unique_lock<std::shared_timed_mutex> mylock(instance->looperMutex);
      instance->looperCv.wait(mylock,
                              [=] { return instance->isLooperReady == true; });
    }
    while (instance->isEmptyQueue() == false) {

      std::shared_ptr<Message> msg = instance->getFirstMessage();
      if(msg)
      {
        string msgName = msg->to_string();
        std::cout << "get first msg: "<< msgName << std::endl;
        instance->handleMessage(msg);
      }
    }
    {
      std::unique_lock<std::shared_timed_mutex> mylock(instance->looperMutex);
      if (instance->isEmptyQueue()) {
        instance->isLooperReady = false;
      }
    }
    instance->looperCv.notify_all();
    if (MyLooper::FEATURE_DYNAMIC_THREAD) {
      instance->releaseThread();
      break;
    }
  }
}

void MyLooper::dispatch(std::shared_ptr<Message> msg) {
  acquireThread();
  if (!mExit && mMessageQueue) {
    mMessageQueue->enqueue(msg);
  }
  {
    lock_guard<std::shared_timed_mutex> lock(looperMutex);
    isLooperReady = true;
  }
  looperCv.notify_all();
}

void MyLooper::dispatchSync(std::shared_ptr<Message> msg) {
  handleMessageSync(msg);
}

size_t MyLooper::getSize() {
  if (mMessageQueue) {
   return mMessageQueue->getSize();
  }
  return 0;
}

bool MyLooper::isEmptyQueue() {
  if (mMessageQueue) {
    return mMessageQueue->isEmpty();
  }
  return true;
}

void MyLooper::dumpMessageQueue() {
  if (mMessageQueue) {
    mMessageQueue->dumpMessageQueue();
  }
}

std::shared_ptr<Message> MyLooper::getFirstMessage() {
  if (mMessageQueue) {
    return mMessageQueue->pop();
  }
  return nullptr;
}

void MyLooper::init(Dispatcher *dispatcher) {
  mDispatcher = dispatcher;
  mName = mDispatcher->to_string() + "-Looper";
  if (mMessageQueue) {
    mMessageQueue->init(mDispatcher->to_string());
  }
}

void MyLooper::handleMessage(std::shared_ptr<Message> msg) {
  mDispatcher->handleMessage(msg);
}

void MyLooper::handleMessageSync(std::shared_ptr<Message> msg) {
  mDispatcher->handleMessageSync(msg);
}
  

void MyLooper::acquireThread() {
  std::lock_guard<std::shared_timed_mutex> lock(looperMutex);
  if (mLooperThread == nullptr && mExit == false) {
    mLooperThread = new std::thread ( myLoop, this );
  }
}

void MyLooper::releaseThread() {
  std::lock_guard<std::shared_timed_mutex> lock(looperMutex);
  if (MyLooper::FEATURE_DYNAMIC_THREAD) {
    if (mLooperThread != nullptr) {
      {
        std::lock_guard<std::shared_timed_mutex> lock(looperMutex);
        mReleaseThread = true;
        isLooperReady = true;
      }
      looperCv.notify_all();

      mLooperThread->join();
      delete mLooperThread;
      mLooperThread = nullptr;
    }
  }
}

void MyLooper::waitForLooperToConsumeAllMsgs() {
  while (true) {
    {
      std::unique_lock<std::shared_timed_mutex> mylock(looperMutex);
      looperCv.wait(mylock, [&] { return isLooperReady == false; });
    }
    if (isEmptyQueue()) {
      std::this_thread::sleep_for(std::chrono::seconds(2));
      return;
    }
  }
}

void MyLooper::killLooper() {
  {
    std::lock_guard<std::shared_timed_mutex> lock(looperMutex);
    mExit = true;
    isLooperReady = true;
  }
  looperCv.notify_all();
}

MessageQueue.h

#pragma once
#include <deque>
#include <shared_mutex>
#include "Message.h"

using std::deque;

class Message;
class MessageQueue {
 protected:
  string mName;
  std::shared_timed_mutex mMutex;
  deque<std::shared_ptr<Message> > mMessages;

 public:
  MessageQueue();
  virtual ~MessageQueue() {}
  virtual void init(string name) { mName = name + "-MessageQueue"; }
  virtual void enqueue(std::shared_ptr<Message> msg);
  virtual size_t getSize();
  virtual void dumpMessageQueue();
  virtual bool isEmpty();
  virtual void clear();
  virtual std::shared_ptr<Message> pop();
  string to_string();

  // void dump();
};

inline MessageQueue::MessageQueue() = default;
inline string MessageQueue::to_string() { return mName; }

MessageQueue.cpp

#include "MessageQueue.h"
#include <shared_mutex>
using std::lock_guard;

void MessageQueue::enqueue(std::shared_ptr<Message> msg) {
  if(msg == nullptr){
    return;
  }
  lock_guard<std::shared_timed_mutex> lock(mMutex);
  mMessages.push_back(msg);
  mMessages.shrink_to_fit();
}

size_t MessageQueue::getSize() {
  lock_guard<std::shared_timed_mutex> lock(mMutex);
  return mMessages.size();
}

bool MessageQueue::isEmpty() {
  lock_guard<std::shared_timed_mutex> lock(mMutex);
  return mMessages.empty();
}

void MessageQueue::dumpMessageQueue() {
  lock_guard<std::shared_timed_mutex> lock(mMutex);
  for (auto& elem : mMessages) {
    printf("[%s]: dequeued message %p", to_string().c_str(), elem.get());
  }
}

void MessageQueue::clear() {
  lock_guard<std::shared_timed_mutex> lock(mMutex);
  mMessages.clear();
}

std::shared_ptr<Message> MessageQueue::pop() {
  if(getSize() > 0) {
    lock_guard<std::shared_timed_mutex> lock(mMutex);
    std::shared_ptr<Message> msg = mMessages.front();
    mMessages.pop_front();
    mMessages.shrink_to_fit();
    return msg;
  } else {
      return nullptr;
  }
}

 处理handler,命名为

 Dispatcher.h

#pragma once
#ifndef __Dispatcher_H__
#define __Dispatcher_H__

#include <memory>
#include <functional>
#include <string>
#include <thread>
//#include <unordered_map>
#include <iostream>

#include "MyLooper.h"
#include "Message.h"
#include "MessageQueue.h"

#define HANDLER(MSG_TYPE, FUNC) {REG_MSG(MSG_TYPE::MESSAGE_NAME), ([this](auto msg) { Module::handler<MSG_TYPE>(std::bind(&FUNC, this, std::placeholders::_1), msg); })}
#define HANDLER_MULTI(MSG_TYPE, name, FUNC) {REG_MSG(name), ([this](auto msg) { Module::handler<MSG_TYPE>(std::bind(&FUNC, this, std::placeholders::_1), msg); })}


class Dispatcher: public std::enable_shared_from_this<Dispatcher> {
 protected:
  std::string mName;
  std::unique_ptr<MyLooper> mLooper;
  /*std::unordered_map<message_id_t,
                     std::function<void(std::shared_ptr<Message>)>,
                     std::hash<message_id_t>,
                     std::equal_to<message_id_t>
                     > */

 public:
  Dispatcher();
  virtual ~Dispatcher();
  virtual void init();
  void dispatch(std::shared_ptr<Message> msg);
  void dispatchSync(std::shared_ptr<Message> msg);
  void handleMessage(std::shared_ptr<Message> msg);
  void handleMessageSync(std::shared_ptr<Message> msg);

  void onMessageArrival(std::shared_ptr<Message> msg);

  string to_string();
  std::thread *getLooperThread();
  size_t getUnProcessedMessageCount();
  bool hasValidLooper();

  template<class M>
  inline void handler(std::function<void(std::shared_ptr<M>)> f, std::shared_ptr<Message> msg) {
    auto event = std::static_pointer_cast<M> (msg);
    f(event);
  }

  void waitForLooperToConsumeAllMsgs();
  void killLooper();

};

inline Dispatcher::Dispatcher() = default;

template <typename M>
class load_Dispatcher
{
    public:
        load_Dispatcher() {
            get_Dispatcher().init();
        }
        M &get_Dispatcher() {
            static M dispatcher{};
            return dispatcher;
        }
};

#endif

Dispatcher.cpp

#include "Dispatcher.h"

using std::lock_guard;
using namespace std;

void Dispatcher::onMessageArrival(std::shared_ptr<Message> msg) {
  if (mLooper != nullptr) {
    mLooper->dispatch(msg);
  }
}

void Dispatcher::dispatch(std::shared_ptr<Message> msg) {
  if (!msg->get_next_hop()) {
    msg->set_next_hop(this);
  }

  if (mLooper != nullptr) {
    mLooper->dispatch(msg);
  }
}

void Dispatcher::dispatchSync(std::shared_ptr<Message> msg) {
  if (mLooper != nullptr) {
    mLooper->dispatchSync(msg);
  }
}

void Dispatcher::handleMessage(std::shared_ptr<Message> msg) {
    cout<<"handle msg: "<< msg->to_string()<< endl;
}

void Dispatcher::handleMessageSync(std::shared_ptr<Message> msg) {
    cout<<"handle msg sync: "<< msg->to_string()<< endl;
}

void Dispatcher::init() {
  if (mLooper != nullptr) {
    mLooper->init(this);
  }
}

Dispatcher::~Dispatcher() {
    mLooper = nullptr;
}

std::thread *Dispatcher::getLooperThread() {
  if (mLooper != nullptr) {
    return mLooper->getLooperThread();
  } else {
    return nullptr;
  }
}

bool Dispatcher::hasValidLooper() {
  if (mLooper != nullptr) {
    return true;
  }
  return false;
}

size_t Dispatcher::getUnProcessedMessageCount() {
  if (mLooper != nullptr) {
    return mLooper->getSize();
  }
  return 0;
}

void Dispatcher::waitForLooperToConsumeAllMsgs() {
  if (mLooper != nullptr) {
    mLooper->waitForLooperToConsumeAllMsgs();
  }
}

void Dispatcher::killLooper() {
  if (mLooper != nullptr) {
    mLooper->killLooper();
  }
}

string Dispatcher::to_string() { return mName; }

可以根据自己的需要，写对应的main.cpp，以及客制化message

#include "Dispatcher.h"
#include <iostream>

using namespace std;

int main() {
    Dispatcher dispatcher;
    dispatcher.init();
    //auto msg = std::make_shared<MyMessage>(string("msg1"));
    cout<<"fine"<<endl;
    return 0;
}

提供一个参考的Makefile文件：


######### Makefile COMMON ########
#c or c++
EXTENSION = cpp
#gcc or g++
CC = g++
#exe name
EXE = main
#source-file-direction space add-more-as: src src1 src2
SUBDIR = src
#.o file direction
OBJ_DIR = obj
#.d file direction
DEP = dep
 
#（including .h file direction）
CPPFLAGS += -I ./inc

# link flags
LDFLAGS += -pthread
#
CFLAGS += -g -Wall -O2 \
          -fsanitize=address
 
#not change lines below

CXX_SOURCES = $(foreach dir,$(SUBDIR), $(wildcard $(dir)/*.$(EXTENSION)))
CXX_OBJECTS = $(patsubst  %.$(EXTENSION), $(OBJ_DIR)/%.o, $(notdir $(CXX_SOURCES)))
DEP_FILES  = $(patsubst  %.$(EXTENSION), $(DEP)/%.d, $(notdir $(CXX_SOURCES)))


$(EXE): $(CXX_OBJECTS)
	$(CC) $(CFLAGS) $(LDFLAGS) $(CXX_OBJECTS) -o $(EXE)
 
$(OBJ_DIR)/%.o: $(SUBDIR)/%.$(EXTENSION)
	if [ ! -d $(OBJ_DIR) ]; then mkdir -p $(OBJ_DIR); fi;\
	$(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
 
$(DEP)/%.d: $(SUBDIR)/%.$(EXTENSION)
	if [ ! -d $(OBJ_DIR) ]; then mkdir -p $(OBJ_DIR); fi;\
	$(CC) $(CFLAGS) $(CPPFLAGS) -MM $< | sed -e 1's,^,$(OBJ_DIR)/,' > $@
 

ifneq "$(MAKECMDGOALS)" "clean"
-include $(DEP_FILES)
endif
 
.PHONY:clean
clean:
	rm -rf $(OBJ_DIR)  $(EXE)

 

 

 

Android C++系列：JNI中的Handler--ALooper
轻口味的专栏
07-05 450
本文回顾了Android 传统Handler机制，以及在JNI中实现Looper和JNI提供的ALooper的使用方式和技巧：使用管道来实现线程通信，并通过自定义通信协议来解决粘包问题。
Android7.0 MessageQueue详解
09-01
在Android 7.0中，MessageQueue主要用于组织和管理待处理的消息，这些消息通常由Handler对象发送，并在适当的时机由Looper处理。理解MessageQueue的工作原理对于优化应用程序性能和解决多线程同步问题至关重要。 1....
Message Queue
01-16
消息队列原型设计的初步版本，有兴趣的可以参考下。并附带有Google Voice Recognition 和TTS相关API的调用方法
Looper和Handler
kanwoerzi
12-11 294
Looper用于在android线程中进行消息处理，默认情况下,一个线程并不和任何Looper绑定。当我们调用Looper.prepare()时，如果当前线程还没有和任何Looper绑定，那么将创建一个Looper让它和当前线程绑定。当我们调用Looper.loop()时，它将对当前线程所对应的Looper的消息进行处理，从消息队列里取消息，处理消息，一直循环直到对该Looper调用quit...
Android MessageQueue 底层实现（C++）
朝花夕拾
06-22 1222
文章目录java 层忽略的 native 函数通过 nativePollOnce 打开 native 世界的大门MessageQueue 向 native 层的延伸native 层的 Loopereventfd 和 epoll 推动消息流转等待超时mWakeEventFd 唤醒mRequests 列表中文件发生 IO 事件发送一个 Native 消息添加一个文件描述符监控请求 java 层忽略的 native 函数 Looper 在取消息时，我们提到 nativePollOnce 可能会阻塞线程。而在发送消
C++ 消息队列
最新发布
wy749929317的博客
04-02 1244
需要注意的是，这个实现是基本的，并且可能不适合所有用例。例如，它并没有处理生产者或消费者过多的情况，这可能导致队列的大小无限增长。在实际应用中，你可能需要添加一些额外的逻辑来处理这种情况，例如限制队列的大小，或者在队列满时阻塞生产者。在C++中，并没有直接提供消息队列（Message Queue）的标准库实现。等工具自己实现一个简单的线程安全消息队列。这个实现允许你在多线程环境中安全地推送和弹出消息。方法，该方法尝试从队列中弹出消息，如果队列为空，则返回。操作，以及在有新消息时通知等待的线程。
c++boost库学习-07-Message Queue
FairLikeSnow的博客
05-21 1209
C++消息队列
使用C++11实现Android系统的Handler机制
08-19
使用C++11实现Android系统的Handler机制 Handler机制是Android系统中的一种跨线程通讯机制，它可以让不同线程之间进行数据交换和通讯。这个机制主要包含三个部分：Handler、Looper和Message Queue。 Handler是...
Thread,Looper,Handler,Message,MessageQueue,MessagePool之间的关系
03-31
在Android系统中，线程（Thread）、Looper、Handler、Message以及MessageQueue和MessagePool是实现异步消息处理机制的关键组件，它们共同构建了一个高效的事件驱动模型。这些组件的关系紧密，协同工作，使得Android...
C++11实现Android Handler机制详解
"使用C++11实现Android系统的Handler机制，通过实例代码详细讲解，旨在提供学习和工作中的参考借鉴价值。" 在Android开发中，Handler机制是一个关键的组件，用于解决多线程间的通信问题，特别是对于UI更新和异步...
message C++
09-22
通過簡訊發送器 企業內部 發送簡訊
队列类Queue的C++实现
04-06
队列类Queue的C++实现
在C++代码中使用Android Handler消息机制（Android or Linux）
陈六生的博客
10-24 1704
前言 在上一篇使用纯Java代码实现Android Handler消息机制文章中，我们主要研究是在Java代码中如何使用Android Handler，其实Android Handler机制在Android源码中也使用了C++代码实现了一套，也可以方便的在C++代码中使用。 ...
C++ BUILDER 消息处理的深入探索
peachblossom的专栏
12-05 1228
在本文中我將告訴你如何以C++Builder來處理Windows訊息，並透過此一能力，來達成在一般VCL元件所無法做到的功能。 何謂Window訊息（Message） 大家都知道 Windows是一套以訊息驅動（Message Driven）的作業系統。然而對於訊息本身卻諱莫如深，只知其然而不知其所以然，雖然C++Builder將某些Windows訊息封裝於事件（Event）系統中，但身為
C++ 消息队列实现
a1534219218的博客
10-11 1297
前言：根据C++ boost实现消息队列 消息的形式可以自定义，这里消息的内容为字符串 #include <iostream> #include <cstring> #include<boost/interprocess/ipc/message_queue.hpp> #include<vector> 进程A是发送消息的进程 ...
C++ 消息循环
1bite 的专栏
06-10 1519
消息循环是非常有用的工具，各平台都能见到它的身影，比如 CFRunLoop、Android Looper、Windows 消息循环等。有时候出于一些原因，我们并不想使用平台相关 API 或者三方库，就想自制一个简易的消息循环将就用，该怎么实现呢.........
基于C++11的跨线程简单消息队列
xuyouqiang1987的博客
03-27 766
目录 示例代码 运行结果 源代码 示例代码 #include "MessageQueue.hpp" #include <thread> #include <iostream> #include <chrono> using namespace std; using namespace std::chrono; MessageQueue<int> mq; void send() { for (int i = 0; i < 10;.
Message Queue c++ 11
slwrq的博客
03-01 1747
#include &lt;iostream&gt;#include &lt;vector&gt;#include &lt;condition_variable&gt;#include &lt;mutex&gt;#include &lt;thread&gt;template &lt;typename T&gt;class MessageQueue {private:    std::mutex mu...
源码浅析: Message/Handler/MessageQueue/Looper
woyaowenzi的专栏
11-13 3557
项目终于没那么忙了！闲下来几天，想想应该学点什么，总结点什么。总体上来，要学的东西实在太多了，看了看自己写的代码，结果发现连最基本的消息机制都没有了解清楚，虽然一直在用Handler发消息（Message），但一直没有去探究它们内部是如何运作的。于是花了一天的时间仔细分析了一下几个基本类的源码，略有所悟，浅析一下。     在探究源码之前，我觉得有必要有一个温习一下Windows的消息机制，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值