接收消息

最新推荐文章于 2022-04-01 16:42:42 发布
最新推荐文章于 2022-04-01 16:42:42 发布
阅读量245 收藏
点赞数
分类专栏： cyber RT 源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38966867/article/details/114288977
版权

接收消息

class Transport   
	template <typename M>
    auto Transport::CreateReceiver(
        const RoleAttributes& attr,
        const typename Receiver<M>::MessageListener& msg_listener,
        const OptionalMode& mode) -> typename std::shared_ptr<Receiver<M>> {
​````略
      RETURN_VAL_IF_NULL(receiver, nullptr);
      if (mode != OptionalMode::HYBRID) {
        receiver->Enable();
        //AddSegment,AddListener
      }
      return receiver;
    }

if (mode != OptionalMode::HYBRID) {
receiver->Enable();
//AddSegment,AddListener
}

class ShmReceiver    
	template <typename M>
    void ShmReceiver<M>::Enable() {
      if (this->enabled_) {
        return;
      }

      dispatcher_->AddListener<M>(
          this->attr_, std::bind(&ShmReceiver<M>::OnNewMessage, this,
                                 std::placeholders::_1, std::placeholders::_2));
      this->enabled_ = true;
    }

dispatcher_->AddListener(
this->attr_, std::bind(&ShmReceiver::OnNewMessage, this,
std::placeholders::_1, std::placeholders::_2));

class ShmDispatcher
    template <typename MessageT>
    void ShmDispatcher::AddListener(const RoleAttributes& self_attr,
                                    const MessageListener<MessageT>& listener) {
      // FIXME: make it more clean
      auto listener_adapter = [listener](const std::shared_ptr<ReadableBlock>& rb,
                                         const MessageInfo& msg_info) {
        auto msg = std::make_shared<MessageT>();
        RETURN_IF(!message::ParseFromArray(
            rb->buf, static_cast<int>(rb->block->msg_size()), msg.get()));
        listener(msg, msg_info);
      };

      Dispatcher::AddListener<ReadableBlock>(self_attr, listener_adapter);
      AddSegment(self_attr);
    }

Dispatcher::AddListener(self_attr, listener_adapter);

class Dispatcher
    template <typename MessageT>
    void Dispatcher::AddListener(const RoleAttributes& self_attr,
                                 const MessageListener<MessageT>& listener) {
      if (is_shutdown_.load()) {
        return;
      }
      uint64_t channel_id = self_attr.channel_id();

      std::shared_ptr<ListenerHandler<MessageT>> handler;
      ListenerHandlerBasePtr* handler_base = nullptr;
      if (msg_listeners_.Get(channel_id, &handler_base)) {
        handler =
            std::dynamic_pointer_cast<ListenerHandler<MessageT>>(*handler_base);
        if (handler == nullptr) {
          AERROR << "please ensure that readers with the same channel["
                 << self_attr.channel_name()
                 << "] in the same process have the same message type";
          return;
        }
      } else {
        ADEBUG << "new reader for channel:"
               << GlobalData::GetChannelById(channel_id);
        handler.reset(new ListenerHandler<MessageT>());
        msg_listeners_.Set(channel_id, handler);
      }
      handler->Connect(self_attr.id(), listener);
    }

handler->Connect(self_attr.id(), listener);

class ListenerHandler 
	template <typename MessageT>
    void ListenerHandler<MessageT>::Connect(uint64_t self_id,
                                            const Listener& listener) {
      auto connection = signal_.Connect(listener);
      if (!connection.IsConnected()) {
        return;
      }

      WriteLockGuard<AtomicRWLock> lock(rw_lock_);
      signal_conns_[self_id] = connection;
    }

auto connection = signal_.Connect(listener);

class Signal     
	ConnectionType Connect(const Callback& cb) {
        auto slot = std::make_shared<Slot<Args...>>(cb);
        {
          std::lock_guard<std::mutex> lock(mutex_);
          slots_.emplace_back(slot);
        }

        return ConnectionType(slot, this);
      }

ConnectionType(slot, this);

class Connection 构造函数
  Connection(const SlotPtr& slot, const SignalPtr& signal)
      : slot_(slot), signal_(signal) {}

ShmDispatcher中ThreadFunc()线程一直运行

class ShmDispatcher    
	void ShmDispatcher::ThreadFunc() {
      ReadableInfo readable_info;
      while (!is_shutdown_.load()) {
        if (!notifier_->Listen(100, &readable_info)) {
          ADEBUG << "listen failed.";
          continue;
        }

        uint64_t host_id = readable_info.host_id();
        if (host_id != host_id_) {
          ADEBUG << "shm readable info from other host.";
          continue;
        }

        uint64_t channel_id = readable_info.channel_id();
        uint32_t block_index = readable_info.block_index();

        {
          ReadLockGuard<AtomicRWLock> lock(segments_lock_);
          if (segments_.count(channel_id) == 0) {
            continue;
          }
          // check block index
          if (previous_indexes_.count(channel_id) == 0) {
            previous_indexes_[channel_id] = UINT32_MAX;
          }
          uint32_t& previous_index = previous_indexes_[channel_id];
          if (block_index != 0 && previous_index != UINT32_MAX) {
            if (block_index == previous_index) {
              ADEBUG << "Receive SAME index " << block_index << " of channel "
                     << channel_id;
            } else if (block_index < previous_index) {
              ADEBUG << "Receive PREVIOUS message. last: " << previous_index
                     << ", now: " << block_index;
            } else if (block_index - previous_index > 1) {
              ADEBUG << "Receive JUMP message. last: " << previous_index
                     << ", now: " << block_index;
            }
          }
          previous_index = block_index;

          ReadMessage(channel_id, block_index);
        }
      }
    }

if (!notifier_->Listen(100, &readable_info)) {
ADEBUG << “listen failed.”;
continue;
}

class ConditionNotifier    
	bool ConditionNotifier::Listen(int timeout_ms, ReadableInfo* info) {
       if (info == nullptr) {
        AERROR << "info nullptr.";
        return false;
      }

      if (is_shutdown_.load()) {
        ADEBUG << "notifier is shutdown.";
        return false;
      }

      std::unique_lock<std::mutex> lck(indicator_->mtx);
      if (next_listen_num_ >= indicator_->written_info_num) {
        uint64_t target = next_listen_num_;
        if (!indicator_->cv.wait_for(
                lck, std::chrono::milliseconds(timeout_ms), [target, this]() {
                  return this->indicator_->written_info_num > target ||
                         this->is_shutdown_.load();
                })) {
          ADEBUG << "timeout";
          return false;
        }

        if (is_shutdown_.load()) {
          AINFO << "notifier is shutdown.";
          return false;
        }
      }

      if (next_listen_num_ == 0) {
        next_listen_num_ = indicator_->written_info_num - 1;
      }

      auto idx = next_listen_num_ % kBufLength;
      *info = indicator_->infos[idx];
      next_listen_num_ += 1;

      return true;
    }

ReadMessage(channel_id, block_index);

class ShmDispatcher
    void ShmDispatcher::ReadMessage(uint64_t channel_id, uint32_t block_index) {
      ADEBUG << "Reading sharedmem message: "
             << GlobalData::GetChannelById(channel_id)
             << " from block: " << block_index;
      auto rb = std::make_shared<ReadableBlock>();
      rb->index = block_index;
      if (!segments_[channel_id]->AcquireBlockToRead(rb.get())) {
        AWARN << "fail to acquire block, channel: "
              << GlobalData::GetChannelById(channel_id)
              << " index: " << block_index;
        return;
      }

      MessageInfo msg_info;
      const char* msg_info_addr =
          reinterpret_cast<char*>(rb->buf) + rb->block->msg_size();

      if (msg_info.DeserializeFrom(msg_info_addr, rb->block->msg_info_size())) {
        OnMessage(channel_id, rb, msg_info);
      } else {
        AERROR << "error msg info of channel:"
               << GlobalData::GetChannelById(channel_id);
      }
      segments_[channel_id]->ReleaseReadBlock(*rb);
    }

OnMessage(channel_id, rb, msg_info);

class ShrmDispatcher
    void ShmDispatcher::OnMessage(uint64_t channel_id,
                                  const std::shared_ptr<ReadableBlock>& rb,
                                  const MessageInfo& msg_info) {
      if (is_shutdown_.load()) {
        return;
      }
      ListenerHandlerBasePtr* handler_base = nullptr;
      if (msg_listeners_.Get(channel_id, &handler_base)) {
        auto handler = std::dynamic_pointer_cast<ListenerHandler<ReadableBlock>>(
            *handler_base);
        handler->Run(rb, msg_info);
      } else {
        AERROR << "Cant find " << GlobalData::GetChannelById(channel_id)
               << "'s handler.";
      }
    }

handler->Run(rb, msg_info);

class ListenerHandler
    template <typename MessageT>  //Message : 
    void ListenerHandler<MessageT>::Run(const Message& msg,
                                        const MessageInfo& msg_info) {
      signal_(msg, msg_info);
      uint64_t oppo_id = msg_info.sender_id().HashValue();
      ReadLockGuard<AtomicRWLock> lock(rw_lock_);
      if (signals_.find(oppo_id) == signals_.end()) {
        return;
      }

      (*signals_[oppo_id])(msg, msg_info);
    }

(*signals_[oppo_id])(msg, msg_info)

class Signal    
	void operator()(Args... args) {
        SlotList local;
        {
          std::lock_guard<std::mutex> lock(mutex_);
          for (auto& slot : slots_) {
            local.emplace_back(slot);
          }
        }

        if (!local.empty()) {
          for (auto& slot : local) {
            (*slot)(args...);
          }
        }

        ClearDisconnectedSlots();
      }

if (!local.empty()) {
for (auto& slot : local) {
(*slot)(args…);
}
}

class Slot   
	void operator()(Args... args) {
        if (connected_ && cb_) {
          cb_(args...);
        }
      }

/*
	// cb_(args...);
	auto listener_adapter = [listener](const std::shared_ptr<ReadableBlock>& rb,
                                         const MessageInfo& msg_info) {
        auto msg = std::make_shared<MessageT>();
        RETURN_IF(!message::ParseFromArray(
            rb->buf, static_cast<int>(rb->block->msg_size()), msg.get()));
        listener(msg, msg_info);
      };
     //
	 listener=ShmReceiver<M>::OnNewMessage
*/

if (connected_ && cb_) {
cb_(args…); //msg, msg_info
}

class ShmDispatcher	
	auto listener_adapter = [listener](const std::shared_ptr<ReadableBlock>& rb,
                                         const MessageInfo& msg_info) {
        auto msg = std::make_shared<MessageT>();
        RETURN_IF(!message::ParseFromArray(
            rb->buf, static_cast<int>(rb->block->msg_size()), msg.get()));
        listener(msg, msg_info);
        //listener=ShmReceiver<M>::OnNewMessage
      };
class Receiver
    template <typename M>
    void Receiver<M>::OnNewMessage(const MessagePtr& msg,
                                   const MessageInfo& msg_info) {
      if (msg_listener_ != nullptr) {
        msg_listener_(msg, msg_info, attr_);
      }
    }

msg_listener_ (msg, msg_info, attr_);

class ReceiverManager    
	template <typename MessageT>
    auto ReceiverManager<MessageT>::GetReceiver函数中
    		[](const std::shared_ptr<MessageT>& msg,
                              const transport::MessageInfo& msg_info,
                              const proto::RoleAttributes& reader_attr) {
                  (void)msg_info;
                  (void)reader_attr;
                  PerfEventCache::Instance()->AddTransportEvent(
                      TransPerf::TRANS_TO, reader_attr.channel_id(),
                      msg_info.seq_num());
                  data::DataDispatcher<MessageT>::Instance()->Dispatch(
                      reader_attr.channel_id(), msg);
                  PerfEventCache::Instance()->AddTransportEvent(
                      TransPerf::WRITE_NOTIFY, reader_attr.channel_id(),
                      msg_info.seq_num());
                }

data::DataDispatcher::Instance()->Dispatch(
reader_attr.channel_id(), msg);

class DataDispatcher
    template <typename T>
    bool DataDispatcher<T>::Dispatch(const uint64_t channel_id,
                                     const std::shared_ptr<T>& msg) {
      BufferVector* buffers = nullptr;
      if (apollo::cyber::IsShutdown()) {
        return false;
      }
      if (buffers_map_.Get(channel_id, &buffers)) {
        for (auto& buffer_wptr : *buffers) {
          if (auto buffer = buffer_wptr.lock()) {
            std::lock_guard<std::mutex> lock(buffer->Mutex());
            buffer->Fill(msg);
          }
        }
      } else {
        return false;
      }
      return notifier_->Notify(channel_id);
    }
/*
template <typename M0>//DataVisito构造函数
class DataVisitor<M0, NullType, NullType, NullType> : public DataVisitorBase
	DataVisitor(uint64_t channel_id, uint32_t queue_size)
          : buffer_(channel_id, new BufferType<M0>(queue_size)) {
        DataDispatcher<M0>::Instance()->AddBuffer(buffer_);
        data_notifier_->AddNotifier(buffer_.channel_id(), notifier_);
      }
*/
海洋2416
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
vue 实现websocket发送消息并实时接收消息
10-15
主要介绍了vue 实现websocket发送消息并实时接收消息,项目结合vue脚手架和websocket来搭建，本文给大家分享实例代码，需要的朋友可以参考下
protobuf的ParseFromArray 解析失败的问题
多看多听多总结
06-28 2万+
前段时间，在解析定义的Message时，总是提示解析失败，刚开始以为是消息号与消息没有对应上，检查后发现消息号与消息是对应的。 后来发现消息的一个字段定义为required,但是没有赋值，将该字段值添加后，解析成功。 指定字段规则 1、required 一个格式良好的消息一定要含有1个这种字段，表示该值是必须要设置的 2、optional 消息格式中该字段可以有0个或1个值（不超过1个
百度apollo cyber中shm共享内存的处理
SWX230162的博客
04-01 1407
百度apollo cyber中shm共享内存的处理 文章目录百度apollo cyber中shm共享内存的处理文件位置主要逻辑condition的构造共享内存的创建和映射indicator1结构共享内存写入共享内存读取 文件位置 cyber transport中关于shm共享内存封装在cyber/transport/shm/中condition_notifier.cc/.h 主要逻辑 condition的构造 这里主要是hash出一个key，并调init来创建共享内存。 ConditionNotifier:
cyber RT概括
qq_38966867的博客
03-02 953
用户通过调用CreateNode函数创造一个节点，该函数是在节点类Node的友元函数。 Nodel类的成员变量·node_channel_impl（NodeChannellmpl）负责创建Reader和Writer。 Writer类中包含transmitter_ , change_conn_, channel_manager_，及JoinTheTopology函数。 Writer类在初始化过程中会调用函数transport::Transport::Instance()->CreateTransmit.
创建一个listener
qq_38966867的博客
03-02 395
创建一个listener void MessageCallback( const std::shared_ptr<apollo::cyber::examples::proto::Chatter>& msg) { AINFO << "Received message seq-> " << msg->seq(); AINFO << "msgcontent->" << msg->content(); }
Apollo 3.5 Cyber 多進程通訊模塊 - Transport (Shared Memory篇）
weixin_44450715的博客
01-14 4556
ROS為不個的node之間的通訊提供了shared memory和network兩種方法 Cyber也提供了差不多的東西，今天就看一看 先上一個全局的圖。當中主要有ShmDispatcher, ShmReceiver, ShmTransmitter,Segment,NotifierBase這幾個。其他的就是實現的細節。當你了解這幾個主要class的互動時，就會基本了解其機制了。 ...
接收消息处理.txt
09-05
企业微信添加应用，设置启用接收API，接收消息处理多种消息类型
微信_发送接收消息_微信_
10-03
一个微信发送接收消息的源代码，写的差不多了
C#消息队列发送及接收
03-25
C#消息队列发送及接收
php版微信开发之接收消息,自动判断及回复相应消息的方法
10-21
主要介绍了php版微信开发之接收消息,自动判断及回复相应消息的方法,涉及基于微信消息处理接口的调用相关操作技巧,需要的朋友可以参考下
百度Apollo系统学习-Cyber RT 通信-底层
qq_25762163的博客
01-16 1万+
上一篇文章介绍了下图中的除Transport部分，本文就来深入解析Transport即cyber通信模块的底层机制。
自动驾驶平台Apollo 5.5阅读手记：Cyber RT中的通信传输
世事难料，保持低调
09-12 1万+
前言 计算框架是自动驾驶系统中的重中之重，也是整个系统得以高效稳定运行的基础。为了实时地完成感知、决策和执行，系统需要一系列的模块相互紧密配合，高效地执行任务流。由于各种原因，这些模块可能位于不同进程，也可能位于不同机器。这就要求计算框架中具有灵活的、高性能的通信机制。我们知道，Apollo在3.5版本中推出了Cyber RT替代了原先的ROS。之前写过两篇相关的文章介绍了其中的调度部分：自动驾驶平台Apollo 3.5阅读手记：Cyber RT中的协程（Coroutine）和自动驾驶平台Apollo 5.
深入学习java源码之MessageFormat.format()与与MessageFormat.parse()
悦分享
01-08 1584
深入学习java源码之MessageFormat.format()与与MessageFormat.parse() new创建数组 java语言使用new操作符来创建数组，语法如下： arrayRefVar = new dataType[arraySize]; 上面的语法语句做了两件事： 一、使用dataType[arraySize]创建了一个数组。 二、把新创建的数组的引用赋值给变量 ...
protobuf进行ParseFromString解包失败的一个常见问题
热门推荐
werflychen的专栏
06-11 4万+
今天在项目中，使用protobuf进行解包时
消息接收与响应处理
Camel
11-14 1170
当普通微信用户向公众账号发消息时，微信服务器将POST消息的XML数据包到开发者填写的URL上。 请注意： 关于重试的消息排重，推荐使用msgid排重。 微信服务器在五秒内收不到响应会断掉连接，并且重新发起请求，总共重试三次。假如服务器无法保证在五秒内处理并回复，可以直接回复空串，微信服务器不会对此作任何处理，并且不会发起重试。详情请见“发送消息-被动回复消息”。 如果开发者需要对用户消息在5秒内立即做出回应，即使用“发送消息-被动回复消息”接口向用户被动回复消息时，可以在 公众平台官网的开发者中心处设置消
微信公众号开发--接收与回复消息（Java）
hgffhh的博客
11-12 1万+
微信公众号开发--接收与回复消息（Java）
fabric故障汇总与解决方案
小树苗
01-09 7473
问题1：阿里云服务器bug不兼容fabric 阿里云的服务器启动会报错如下： Error: error getting endorser client for channel: endorser client failed to connect to peer0.org1.example.com:7051: failed to create new connection: connection...
发布和接收消息
Leo_starr的博客
10-05 286
1.发布消息 1.发布消息 ros::init(argc, argv, "talker"); //初始化节点 ros::NodeHandle n; //定义句柄 //定义publisher pulisher = handle.advertise<msgType>("topic",queue_size) ros::Publis...
class RecieverThread extends Thread{ @Override public void run() { byte[] data=new byte[1024]; //需要一个循环一直接受消息 while(true){ //创建包裹对象 DatagramPacket packet=new DatagramPacket(data,data.length); //等待接收消息 try { //等待接收消息,会阻塞 socket.receive(packet); //如果接收到消息，上面阻塞会解除 int len= packet.getLength(); String msg=new String(data,0,len); System.out.println("收到消息了:"+msg); //接收的消息添加到消息面板 msgAddToMsgPanel(msg,FlowLayout.LEFT); } catch (IOException e) { throw new RuntimeException(e); } } }请给出详细解释
最新发布
06-07
9. `System.out.println("收到消息了:"+msg)`在控制台输出接收到的消息。 10. `msgAddToMsgPanel(msg,FlowLayout.LEFT)`将接收到的消息添加到聊天界面中的消息面板中，`FlowLayout.LEFT`表示将消息靠左对齐。 11. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海洋2416

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值