muduo Poller 和 Channel

最新推荐文章于 2024-07-12 10:45:15 发布
最新推荐文章于 2024-07-12 10:45:15 发布
阅读量184 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42653406/article/details/119955376
版权

muduo Poller 和 Channel

Poller

class Poller 是IO multiplexing（多路复用）的封装，是一个纯虚类。
一个 Poller 只属于一个 class EventLoop，每一个线程最多只能有一个 class EventLoop

///
/// Base class for IO Multiplexing
///
/// This class doesn't own the Channel objects.
class Poller : noncopyable
{
 public:
  typedef std::vector<Channel*> ChannelList;

  Poller::Poller(EventLoop* loop)
  : ownerLoop_(loop){}
  
  virtual ~Poller();

  /// Polls the I/O events.
  /// Must be called in the loop thread.
  virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels) = 0;

  /// Changes the interested I/O events.
  /// Must be called in the loop thread.
  virtual void updateChannel(Channel* channel) = 0;

  /// Remove the channel, when it destructs.
  /// Must be called in the loop thread.
  virtual void removeChannel(Channel* channel) = 0;

  virtual bool hasChannel(Channel* channel) const;

  static Poller* newDefaultPoller(EventLoop* loop);

  void assertInLoopThread() const
  {
    ownerLoop_->assertInLoopThread();
  }

 protected:
  typedef std::map<int, Channel*> ChannelMap;
  ChannelMap channels_;

 private:
  EventLoop* ownerLoop_;
};

ChannelMap channels_ 记录了该 Poller 所监控的所有 fd（文件描述符）到每个 fd 所对应的 class Channel （Channel 保存了此 fd，并记录了业务对此 fd 所关心的事件）之间的映射

Poller 的作用是：

  1. 记录监控了哪些 fd，和每个 fd 所对应的 Channel（由updateChannel，removeChannel设置）
  2. 调用 poll(int timeoutMs, ChannelList* activeChannels)，找的被监控的所有 fd 中其所关心的事件发生了的 fd 所对应的 Channel，将发生了的事件通过调用 Channel::set_revents 记录在该 Channel 中，并返回这些 Channel

poll updateChannel removeChannel hasChannel，这四个接口都不是线程安全的，分别只会被 EventLoop::loop，EventLoop::updateChannel，EventLoop::hasChannel，EventLoop::removeChannel 调用。

EventLoop::loop EventLoop::updateChannel EventLoop::hasChannel EventLoop::removeChannel 也不是线程安全的，只能在 EventLoop对象所属的线程调用。这样就保证了被调用的时候，该线程是没有卡在 ::poll 或 ::epoll 上的，就可以安全的修改 ChannelMap channels_ 和 PollFdList pollfds_（PollPoller）或调用 ::epoll_ctl对 epollfd_（EPollPoller）进行修改

muduo中同时支持poll和epoll两种多路复用机制，分别由class PollPoller 和class EPollPoller 实现

static Poller* Poller::newDefaultPoller(EventLoop* loop)
{
  if (::getenv("MUDUO_USE_POLL"))
  {
    return new PollPoller(loop);
  }
  else
  {
    return new EPollPoller(loop);
  }
}

PollPoller

///
/// IO Multiplexing with poll(2).
///
class PollPoller : public Poller
{
 public:

  PollPoller::PollPoller(EventLoop* loop)
  : Poller(loop){}
  
  ~PollPoller() override;

  Timestamp poll(int timeoutMs, ChannelList* activeChannels) override;
  void updateChannel(Channel* channel) override;
  void removeChannel(Channel* channel) override;

 private:
  void fillActiveChannels(int numEvents,
                          ChannelList* activeChannels) const;

  typedef std::vector<struct pollfd> PollFdList;
  PollFdList pollfds_;
};

/* Data structure describing a polling request.  */
struct pollfd
{
  int fd;			/* File descriptor to poll.  */
  short int events;		/* Types of events poller cares about.  */
  short int revents;		/* Types of events that actually occurred.  */
};

PollFdList pollfds_ 记录了 PollPoller 需要监控的所有 fd

updateChannel

void PollPoller::updateChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  LOG_TRACE << "fd = " << channel->fd() << " events = " << channel->events();
  if (channel->index() < 0)
  {
    // a new one, add to pollfds_
    assert(channels_.find(channel->fd()) == channels_.end());
    struct pollfd pfd;
    pfd.fd = channel->fd();
    pfd.events = static_cast<short>(channel->events());
    pfd.revents = 0;
    pollfds_.push_back(pfd);
    int idx = static_cast<int>(pollfds_.size())-1;
    channel->set_index(idx);
    channels_[pfd.fd] = channel;
  }
  else
  {
    // update existing one
    assert(channels_.find(channel->fd()) != channels_.end());
    assert(channels_[channel->fd()] == channel);
    int idx = channel->index();
    assert(0 <= idx && idx < static_cast<int>(pollfds_.size()));
    struct pollfd& pfd = pollfds_[idx];
    assert(pfd.fd == channel->fd() || pfd.fd == -channel->fd()-1);
    pfd.fd = channel->fd();
    pfd.events = static_cast<short>(channel->events());
    pfd.revents = 0;
    if (channel->isNoneEvent())
    {
      // ignore this pollfd
      pfd.fd = -channel->fd()-1;
    }
  }
}
  1. 新增一个 Channel （不会不关心任何事件）：
    新建一个并初始化一个 struct pollfd，加入到 PollFdList pollfds_ 中
    设置 Channel 的 index 为其在 PollFdList pollfds_ 的 offset 便于更新的时候查找
    更新 ChannelMap channels_，新添加一个映射 channels_[pfd.fd] = channel
  2. 更新一个 Channel（更新对 fd 所关心事件）：
    根据 Channel 的 index 从 PollFdList pollfds_ 找到其对应的 struct pollfd
    更新 pfd.events
    如果不关心任何事件，则把 pfd.fd 设置成负数

Poll

Timestamp PollPoller::poll(int timeoutMs, ChannelList* activeChannels)
{
  // XXX pollfds_ shouldn't change
  int numEvents = ::poll(&*pollfds_.begin(), pollfds_.size(), timeoutMs);
  ...
  Timestamp now(Timestamp::now());
  if (numEvents > 0)
  {
    LOG_TRACE << numEvents << " events happened";
    fillActiveChannels(numEvents, activeChannels);
  }
  else if (numEvents == 0)
  {
    LOG_TRACE << " nothing happened";
  }
  else
  {
    // error
    ...
  }
  return now;
}

void PollPoller::fillActiveChannels(int numEvents,
                                    ChannelList* activeChannels) const
{
  for (PollFdList::const_iterator pfd = pollfds_.begin();
      pfd != pollfds_.end() && numEvents > 0; ++pfd)
  {
    if (pfd->revents > 0)
    {
      --numEvents;
      ChannelMap::const_iterator ch = channels_.find(pfd->fd);
      assert(ch != channels_.end());
      Channel* channel = ch->second;
      assert(channel->fd() == pfd->fd);
      channel->set_revents(pfd->revents);
      // pfd->revents = 0;
      activeChannels->push_back(channel);
    }
  }
}

调用 ::poll ，::poll 返回后立刻记录下时间

  1. 如果 numEvents > 0则调用 fillActiveChannels，遍历 PollFdList pollfds_ 找到所有的 pfd->revents > 0 的 struct pollfd，然后再找到其对应的 Channel，然后 channel->set_revents(pfd->revents)，最后将其加入 ChannelList* activeChannels
  2. 如果 numEvents == 0说明 ::poll 的 timeoutMs 超时

返回::poll 返回后记录下的时间

EPollPoller

class EPollPoller : public Poller
{
 public:
  EPollPoller(EventLoop* loop);
  ~EPollPoller() override;

  Timestamp poll(int timeoutMs, ChannelList* activeChannels) override;
  void updateChannel(Channel* channel) override;
  void removeChannel(Channel* channel) override;

 private:
  static const int kInitEventListSize = 16;

  void fillActiveChannels(int numEvents,
                          ChannelList* activeChannels) const;
  void update(int operation, Channel* channel);

  typedef std::vector<struct epoll_event> EventList;

  int epollfd_;
  EventList events_;
};

EPollPoller::EPollPoller(EventLoop* loop)
  : Poller(loop),
    epollfd_(::epoll_create1(EPOLL_CLOEXEC)),
    events_(kInitEventListSize)
{
}

EPollPoller::~EPollPoller()
{
  ::close(epollfd_);
}

EventList events_ 不是保存的所有关注的 fd 列表，而是保存的每一次 epoll_wait 调用返回的活动 fd 列表，初始大小为 kInitEventListSize = 16，每一次 epoll_wait 都会复用 EventList events_

updateChannel

void EPollPoller::updateChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  const int index = channel->index();
  if (index == kNew || index == kDeleted)
  {
    // a new one, add with EPOLL_CTL_ADD
    int fd = channel->fd();
    if (index == kNew)
    {
      channels_[fd] = channel;
    }
    channel->set_index(kAdded);
    update(EPOLL_CTL_ADD, channel);
  }
  else
  {
    // update existing one with EPOLL_CTL_MOD/DEL
    int fd = channel->fd();
    if (channel->isNoneEvent())
    {
      update(EPOLL_CTL_DEL, channel);
      channel->set_index(kDeleted);
    }
    else
    {
      update(EPOLL_CTL_MOD, channel);
    }
  }
}
  1. 新增一个 Channel （不会不关心任何事件） channel->index() == kNew ：
    更新 ChannelMap channels_，新添加一个映射 channels_[fd] = channel
    设置 Channel 的 index 为 kNew
    update(EPOLL_CTL_ADD, channel)
  2. 更新一个 Channel（更新对 fd 所关心事件）：
    不关心任何事 -> 关心某些事：
    channel->set_index(kAdded); update(EPOLL_CTL_ADD, channel);
    关心某些事 -> 不关心任何事：
    channel->set_index(kDeleted); update(EPOLL_CTL_DEL, channel);
    关心某些事 -> 关心某些事：
    update(EPOLL_CTL_MOD, channel)
void EPollPoller::update(int operation, Channel* channel)
{
  struct epoll_event event;
  memZero(&event, sizeof event);
  event.events = channel->events();
  event.data.ptr = channel;
  int fd = channel->fd();
  
  if (::epoll_ctl(epollfd_, operation, fd, &event) < 0)
  {
    // error
  }
}

typedef union epoll_data
{
  void *ptr;
  int fd;
  uint32_t u32;
  uint64_t u64;
} epoll_data_t;

struct epoll_event
{
  uint32_t events;	/* Epoll events */
  epoll_data_t data;	/* User data variable */
} __EPOLL_PACKED;

epoll_data 是个 union ，muduo 使用的是 void *ptr，用于存放 Channel *，这样可以减少一步lookup

Poll

Timestamp EPollPoller::poll(int timeoutMs, ChannelList* activeChannels)
{
  int numEvents = ::epoll_wait(epollfd_,
                               &*events_.begin(),
                               static_cast<int>(events_.size()),
                               timeoutMs);
  Timestamp now(Timestamp::now());
  if (numEvents > 0)
  {
    fillActiveChannels(numEvents, activeChannels);
    if (implicit_cast<size_t>(numEvents) == events_.size())
    {
      events_.resize(events_.size()*2);
    }
  }
  else if (numEvents == 0)
  {
    LOG_TRACE << "nothing happened";
  }
  else
  {
    // error 
  }
  return now;
}

void EPollPoller::fillActiveChannels(int numEvents,
                                     ChannelList* activeChannels) const
{
  assert(implicit_cast<size_t>(numEvents) <= events_.size());
  for (int i = 0; i < numEvents; ++i)
  {
    Channel* channel = static_cast<Channel*>(events_[i].data.ptr);
    channel->set_revents(events_[i].events);
    activeChannels->push_back(channel);
  }
}

调用 ::epoll_wait ，::epoll_wait 返回后立刻记录下时间

  1. 如果 numEvents > 0则调用 fillActiveChannels，EventList events_ 中已经存在了 numEvents 个活动 fd 各自所对应的 struct epoll_event，epoll_data 的ptr存放了 Channel *，然后 channel->set_revents(events_[i].events)，最后将其加入 ChannelList* activeChannels
    如果 numEvents == events_.size()，说明 events_的大小可能不够，对它进行两倍扩容
  2. 如果 numEvents == 0说明 ::epoll_wait 的 timeoutMs 超时

返回::epoll_wait 返回后记录下的时间

Channel

每个 Channel 对象自始至终只属于一个 EventLoop，因此每一个 Channel 对象只属于某一个IO线程。每个 Channel 对象自始至终只负责一个 fd 的 IO事件分发，但它并不拥有这个 fd（class Socket 拥有此 fd），也不需要在析构的时候关闭 fd。Channel 会把不同的IO事件分发为不同的回调函数（readCallback_，writeCallback_，closeCallback_，errorCallback_）。Channel 的生命周期由其 owner class负责管理，它一般是其他 class 的直接或间接成员
例如 Acceptor 中的 Channel acceptChannel_ 成员，TcpConnection 中的 Channel channel_ 成员

///
/// A selectable I/O channel.
///
/// This class doesn't own the file descriptor.
/// The file descriptor could be a socket,
/// an eventfd, a timerfd, or a signalfd
class Channel : noncopyable
{
 public:
  typedef std::function<void()> EventCallback;
  typedef std::function<void(Timestamp)> ReadEventCallback;

  Channel(EventLoop* loop, int fd);
  ~Channel();

  void handleEvent(Timestamp receiveTime);
  void setReadCallback(ReadEventCallback cb)
  { readCallback_ = std::move(cb); }
  void setWriteCallback(EventCallback cb)
  { writeCallback_ = std::move(cb); }
  void setCloseCallback(EventCallback cb)
  { closeCallback_ = std::move(cb); }
  void setErrorCallback(EventCallback cb)
  { errorCallback_ = std::move(cb); }

  /// Tie this channel to the owner object managed by shared_ptr,
  /// prevent the owner object being destroyed in handleEvent.
  void tie(const std::shared_ptr<void>& obj)
  {
	  tie_ = obj;
	  tied_ = true;
  }

  int fd() const { return fd_; }
  int events() const { return events_; }
  void set_revents(int revt) { revents_ = revt; } // used by pollers
  bool isNoneEvent() const { return events_ == kNoneEvent; }

  void enableReading() { events_ |= kReadEvent; update(); }
  void disableReading() { events_ &= ~kReadEvent; update(); }
  void enableWriting() { events_ |= kWriteEvent; update(); }
  void disableWriting() { events_ &= ~kWriteEvent; update(); }
  void disableAll() { events_ = kNoneEvent; update(); }
  bool isWriting() const { return events_ & kWriteEvent; }
  bool isReading() const { return events_ & kReadEvent; }

  // for Poller
  int index() { return index_; }
  void set_index(int idx) { index_ = idx; }

  EventLoop* ownerLoop() { return loop_; }
  void remove() {
    assert(isNoneEvent());
    addedToLoop_ = false;
    loop_->removeChannel(this);
  }

 private:

  void update() {
    addedToLoop_ = true;
    loop_->updateChannel(this);
  }
  void handleEventWithGuard(Timestamp receiveTime);

  static const int kNoneEvent = 0;
  static const int kReadEvent = POLLIN | POLLPRI;
  static const int kWriteEvent = POLLOUT;

  EventLoop* loop_;
  const int  fd_;
  int        events_; // 用户关心的IO事件
  int        revents_; // 目前活动的事件，由Poller设置。it's the received event types of epoll or poll
  int        index_; // used by Poller.

  std::weak_ptr<void> tie_; // 用于绑定这个 channel 对象所属的对象
  bool tied_; // 是否绑定了这个 channel 对象所属的对象
  bool eventHandling_; // 是否正在执行用户指定的事件的回调函数
  bool addedToLoop_;
  ReadEventCallback readCallback_;
  EventCallback writeCallback_;
  EventCallback closeCallback_;
  EventCallback errorCallback_;
};

Channel 的作用是：

  1. 记录 fd，关心的 fd 事件（可读，可写，关闭，出错）， fd 事件分别的回调函数
  2. 设置开始关心某些事件，设置停止关心某些事件
  3. 根据已经发生的事件，分别调用事件的回调函数

Channel 的函数成员都只能其所属的EventLoop所属的线程被调用，因此更新数据成员都不必加锁

设置关心事件

Channel::update -> EventLoop::updateChannel -> EPollPoller::updateChannel 或者 PollPoller::updateChannel 见上面

class Channel : noncopyable
{
 public:
  ...

  void enableReading() { events_ |= kReadEvent; update(); }
  void disableReading() { events_ &= ~kReadEvent; update(); }
  void enableWriting() { events_ |= kWriteEvent; update(); }
  void disableWriting() { events_ &= ~kWriteEvent; update(); }
  void disableAll() { events_ = kNoneEvent; update(); }
  bool isWriting() const { return events_ & kWriteEvent; }
  bool isReading() const { return events_ & kReadEvent; }

  ...
};

void Channel::update()
{
  addedToLoop_ = true;
  loop_->updateChannel(this);
}

void EventLoop::updateChannel(Channel* channel)
{
  assert(channel->ownerLoop() == this);
  assertInLoopThread();
  poller_->updateChannel(channel);
}

handleEvent()

Channel::handleEvent() 是 Channel 的核心，它由 EventLoop::loop()调用，
在这里插入图片描述
它的核心功能是根据 revent_的值分别调用不同的用户回调

void Channel::handleEvent(Timestamp receiveTime)
{
  std::shared_ptr<void> guard;
  if (tied_) // 绑定了其所属的对象
  {
    guard = tie_.lock(); 
    if (guard) // 其对象没有被析构
    {
      handleEventWithGuard(receiveTime);
    }
  }
  else
  {
    handleEventWithGuard(receiveTime);
  }
}

void Channel::handleEventWithGuard(Timestamp receiveTime)
{
  eventHandling_ = true;
  if ((revents_ & POLLHUP) && !(revents_ & POLLIN))
  {
    if (closeCallback_) closeCallback_();
  }
  if (revents_ & POLLNVAL)
  {
    LOG_WARN << "fd = " << fd_ << " Channel::handle_event() POLLNVAL";
  }
  if (revents_ & (POLLERR | POLLNVAL))
  {
    if (errorCallback_) errorCallback_();
  }
  if (revents_ & (POLLIN | POLLPRI | POLLRDHUP))
  {
    if (readCallback_) readCallback_(receiveTime);
  }
  if (revents_ & POLLOUT)
  {
    if (writeCallback_) writeCallback_();
  }
  eventHandling_ = false;
}
Branzino
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
muduo库的 poller 接口类和Channel分析
andylau00j的专栏
07-03 550
muduo库内的 timerfd eventfd socketfd 等文件描述符，一般注册读写事件一般通过以下流程： 当一个fd想要注册可读事件时，首先通过 Channel::enableReading()-&gt;  Channel::update(this)-&gt;  EventLoop::updateChannel(Channel)-&gt;  Poller::updateChanne...
muduo库的PollPoller类剖析
FreeeLinux's blog
12-04 1202
muduo库中唯一使用面向对象的地方就在Poller，它有两个派生类，分别是PollPoller和EPollPoller。可以实现两种I/O多路复用机制。 Poller Poller的数据成员有： protected: typedef std::map ChannelMap; ChannelMap channels_; private: EventLoop* ownerLoo
muduo网络库学习—EventLoop，Channel，Poller（2）
qq_41409979的博客
05-07 712
muduo网络库学习（2） 文章目录muduo网络库学习（2）前言一、oneloop per thread二、EventLoop事件循环流程1.事件循环流程2.读入数据总结 前言 本章主要记录muduo库中的事件循环功能实现即EventLoop类实现。 一、oneloop per thread 为了保证每一个线程只有一个loop循环，muduo在每个线程中创建了一个变量记录EventLoop的指针。 namespace mduo{ namespace net{ // 当前线程EventLoop对象指
muduo:Channel、Poller分析
KangRoger的专栏
08-04 2480
Channel是Reactor结构中的“事件”，它自始至终都属于一个EventLoop，负责一个文件描述符的IO事件。Poller是实现了IO复用，是个虚基类。
muduo--Reactor的关键构成
wuqiyi_71的博客
07-08 226
Reactor（muduo中主要涉及Eventloop，Poller，Channel）一个事件循环对应一个IO线程，IO线程执行EventLoop事件主循环，该主循环loop调用IO复用器poller监听事件集合，并将就绪事件通过事件分发器Channel执行相应的事件回调。1、Eventloop事件循环：反应器（reactor）：负责IO和定时器事件的分派。关键函数：void EventLoop:...
muduo 木铎
11-18
《muduo 木铎：探索中国开源的多线程编程库》 “muduo”是一个由中国开发者编写的开源库，专为多线程编程设计。它以其高效、稳定和易于使用的特性，在国内的软件开发领域中逐渐受到广泛关注。在深入理解muduo之前，...
中国光大银行信用卡网上商城系统设计与实现_杨木铎.caj
09-06
中国光大银行信用卡网上商城系统设计与实现_杨木铎
人教版高中语文(选修)先秦诸子选读各课原文.doc
10-03
"天将以夫子为木铎"，木铎是古代宣教的工具，象征着孔子被看作是传播道德和智慧的人。这反映出孔子在教育和道德上的重要作用。 4. 激励与批评： 孔子对弟子们的态度多样，既有鼓励如"当仁，不让于师"，鼓励他们在...
河南省鹤壁市淇滨高级中学2020学年高二语文上学期第一次周考试题(1).doc
10-14
5. 音响工具的寓意：木铎和木鼓等工具传达黑暗与光明的对立，强化了自然与文化等对立结构的表达。 6. 仪式时间的统一：寒食节的时间在古代各地不一，但后来统一为冬至后的第一百零五天，这表明了文化传承和规范化的...
教（学）案-天下有道-丘也不与易也.doc
10-12
5. 选段分析：选段中，仪封人对孔子的评价反映了孔子在当时被视为传达天意的“木铎”，即传递道德和智慧的象征，显示了孔子在社会中的崇高地位和影响力。 综上所述，这篇教学方案旨在让学生深入了解孔子及其弟子的...
Muduo源码：Poller类 + EpollPoller类详解
ciaiy的博客
06-02 523
前言 最近开始看陈硕大佬的muduo, 在这里记下所学到的知识叭. 第一次写关于阅读源代码的博客, 可能更多的是通过注释的方式来解释作者的思路, 如果有任何的疑问或意见, 欢迎评论. 正文 Poller介绍 eventloop类中有一个成员叫做poller_, 这个poller_负责着所有的IO事件, 在整个eventloop中起到了决定性的作用. std::unique_ptr<Po...
muduo库的EpollPoller剖析
FreeeLinux's blog
12-06 1830
EpollPoller和PollPoller一样，都是muduo库对I/O复用机制的封装，不过默认使用的是EpollPoller。在EventLoop中初始化构造poller_,调用newDefaultPoller(this)，构造默认的poller。EventLoop::EventLoop() : looping_(false), //表示还未循环 quit_(false),
Muduo网络库源码分析（一） EventLoop事件循环（Poller和Channel）
NK_test的博客
04-04 6661
从这一篇博文起，我们开始剖析Muduo网络库的源码，主要结合《Linux多线程服务端编程》和网上的一些学习资料！ （一）TCP网络编程的本质：三个半事件 1. 连接的建立，包括服务端接受(accept) 新连接和客户端成功发起(connect) 连接。TCP 连接一旦建立，客户端和服务端是平等的，可以各自收发数据。 2. 连接的断开，包括主动断开(close 或shutdown) 和被动断开
Mudu分析及总结（三）Poller、PollPoller
蜗牛，为梦想而生。
05-27 1365
Poller是基类，PollPoller和EPollPoller是子类，本文只介绍Poller和PollPoller。 Poller操作Channel对象，但是不拥有Channel对象。 PollPoller是基于poll实现，EPollPoller是基于epoll实现。 一、类关系图 二、工作时序图 三、poll方法基本概念 1、poll() int poll (struct pollf...
随笔记录zmq中的poller()用法
yanfei912的博客
10-31 8168
一个线程中如果有多个sokect,同时需要收发数据时,zmq提供polling sockets实现，不用在send()或者recv()时阻塞socket。 在poller中POLLIN和POLLOUT的区别是pollin在recv（）端，负责刷新recv端口，来接受信息，POLLOUT在send()端口，负责刷新send端，来发送消息
蓝牙协议分析(7)_BLE连接有关的技术分析
huangshuyi529的专栏
02-25 416
蓝牙协议分析(7)_BLE连接有关的技术分析作者：wowo 发布于：2016-7-1 17:17 原文地址：http://www.wowotech.net/bluetooth/ble_connection.html 分类：蓝牙 1. 前言 了解蓝牙的人都知道，在经典蓝牙中，保持连接（Connection）是一个相当消耗资源（power和带宽）的过程。特别是当没有数据传输的时候，所消耗...
【NIO详解】Channel、Selector与Pipe
白夜行
06-12 4640
Channel1.定义： Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过Stream是单向的，如：InputStream, OutputStream.而Channel是双向的，既可以用来进行读操作，又可以用来进行写操作。但Channel 本身不能直接访问数据，Channel 只能与Buffer 进行交互。图解： 2.常用类•FileChannel：用于读
Golang之Channel的理解与应用
Erick Lv的笔记
08-21 1882
博客参考自：https://golangbot.com/buffered-channels-worker-pools/ 基础应用 使用channel的阻塞性质作为延时函数。 package main import ( &amp;quot;fmt&amp;quot; ) func hello(done chan bool) { fmt.Println(&amp;quot;Hello world goroutine !&amp;quot;) ...
函数模板与类模板
最新发布
程序员_小兵
07-12 1548
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
windows muduo
08-26
muduo是一个基于Linux的C++网络库，它专注于高性能和可伸缩性。根据引用，muduo是在Linux操作系统上开发和编译的。因此，它不支持Windows操作系统。 muduo使用了一些Linux特定的系统调用和功能，如timerfd和eventfd...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值