net3. Reactor关键结构——Poller轮询器类

最新推荐文章于 2025-10-28 00:29:40 发布
原创 最新推荐文章于 2025-10-28 00:29:40 发布 · 462 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
从零开始搭建muduo网络库

当前文章被收录于：

从零开始搭建muduo网络库
32 篇文章 7 人学习

从零开始搭建muduo网络库

订阅专栏 查看详情

Poller类图
在这里插入图片描述
Poller类

  1. Poller是一个抽象类，Poller是对I/O复用的抽象，有两个派生类PollPoller和EPollPoller，一个EventLoop包含一个Poller对象。
  2. PollPoller和EPollPoller使用一个map来存放描述符fd和对应的Channel类型的指针，这样我们就可以通过fd很方便的得到Channel了。

1.Poller类

数据成员：

EventLoop* ownerLoop_：Poller所属EventLoop

typedef

typedef std::vector<Channel*> ChannelList

成员函数：

Poller(EventLoop* loop)：构造函数，记录Poller所属EventLoop
virtual ~Poller()：析构函数
virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels) = 0：poll()填充活动通道的列表activeChannels，返回当前时间
virtual void updateChannel(Channel* channel) = 0：updateChannel()用于注册或者更新通道所关注的事件
virtual void removeChannel(Channel* channel) = 0：removeChannel()用于移除通道所关注的事件
static Poller* newDefaultPoller(EventLoop* loop)：在DefaultPoller.cc生成PollPoller类或者EPollPoller类
void assertInLoopThread()：断言当前处于创建该对象的线程中

Poller.h

#ifndef MUDUO_NET_POLLER_H
#define MUDUO_NET_POLLER_H

#include <vector>
#include <boost/noncopyable.hpp>

#include <muduo/base/Timestamp.h>
#include <muduo/net/EventLoop.h>

namespace muduo
{
namespace net
{

class Channel;

///
/// Base class for IO Multiplexing
///
/// This class doesn't own the Channel objects.
class Poller : boost::noncopyable
{
 public:
  typedef std::vector<Channel*> ChannelList;
  
  //构造函数记录Poller所属EventLoop
  Poller(EventLoop* 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;

  static Poller* newDefaultPoller(EventLoop* loop);
  //断言当前处于创建该对象的线程中
  void assertInLoopThread()
  {
    ownerLoop_->assertInLoopThread();
  }

 private:
 // Poller所属EventLoop 
 EventLoop* ownerLoop_;	
};

}
}
#endif  // MUDUO_NET_POLLER_H

Poller.cc

#include <muduo/net/Poller.h>

using namespace muduo;
using namespace muduo::net;

Poller::Poller(EventLoop* loop)
  : ownerLoop_(loop)
{
}

Poller::~Poller()
{
}

DefaultPoller.cc

#include <muduo/net/Poller.h>
#include <muduo/net/poller/PollPoller.h>
#include <muduo/net/poller/EPollPoller.h>

#include <stdlib.h>

using namespace muduo::net;

//生成PollPoller类或者EPollPoller类
Poller* Poller::newDefaultPoller(EventLoop* loop)
{  //实际上生成的是EPollPoller类型的对象
  if (::getenv("MUDUO_USE_POLL"))
  {
    return new PollPoller(loop);
  }
  else
  {
    return new EPollPoller(loop);
  }
}

2.PollPoller类

数据成员：

PollFdList pollfds_：所关注的文件描述符列表pollfds_
ChannelMap channels_：所关注的通道列表channels_，由fd对应channel

typedef

typedef std::vector PollFdList;
typedef std::map<int, Channel*> ChannelMap;

成员函数：

PollPoller(EventLoop* loop)：构造函数，调用Poller类的构造函数Poller(loop)初始化Poller所属EventLoop，即ownerLoop_
virtual ~PollPoller()：析构函数
virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels)：poll()获得当前活动的IO事件，填充活动通道的列表activeChannels，并返回当前时间
virtual void updateChannel(Channel* channel)：updateChannel()的主要功能是负责维护和更新pollfds_，用于注册或者更新通道所关注的事件
virtual void removeChannel(Channel* channel)：removeChannel()用于移除通道所关注的事件
void fillActiveChannels(int numEvents, ChannelList* activeChannels) const：poll()调用fillActiveChannels()，在activeChannels中放入numEvents个活动通道

PollPoller.h

#ifndef MUDUO_NET_POLLER_POLLPOLLER_H
#define MUDUO_NET_POLLER_POLLPOLLER_H

#include <muduo/net/Poller.h>

#include <map>
#include <vector>

struct pollfd;

namespace muduo
{
namespace net
{

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

  PollPoller(EventLoop* loop);
  virtual ~PollPoller();
  
  //poll()填充活动通道的列表activeChannels，返回当前时间
  virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels);
  //updateChannel()用于注册或者更新通道所关注的事件
  virtual void updateChannel(Channel* channel);
  //removeChannel()用于移除通道所关注的事件
  virtual void removeChannel(Channel* channel);

 private:
  //poll()调用fillActiveChannels()，在activeChannels中放入numEvents个活动通道
  void fillActiveChannels(int numEvents,
                          ChannelList* activeChannels) const;
  //vector类型的PollFdList，存储pollfd类型的结构数组
  typedef std::vector<struct pollfd> PollFdList;
  //ChannelMap类型中key是文件描述符，value是Channel*
  typedef std::map<int, Channel*> ChannelMap;	
  //文件描述符列表pollfds_
  PollFdList pollfds_;
  //所关注的通道列表channels_
  ChannelMap channels_;
};

}
}
#endif  // MUDUO_NET_POLLER_POLLPOLLER_H

PollPoller.cc

#include <muduo/net/poller/PollPoller.h>

#include <muduo/base/Logging.h>
#include <muduo/base/Types.h>
#include <muduo/net/Channel.h>

#include <assert.h>
#include <poll.h>

using namespace muduo;
using namespace muduo::net;

PollPoller::PollPoller(EventLoop* loop)
  : Poller(loop)
{
}

PollPoller::~PollPoller()
{
}

Timestamp PollPoller::poll(int timeoutMs, ChannelList* activeChannels)
{
  //调用标准的::poll
  int numEvents = ::poll(&*pollfds_.begin(), pollfds_.size(), timeoutMs);
  Timestamp now(Timestamp::now());
  if (numEvents > 0)
  {
    LOG_TRACE << numEvents << " events happended";
    fillActiveChannels(numEvents, activeChannels);
  }
  else if (numEvents == 0)
  {
    LOG_TRACE << " nothing happended";
  }
  else
  {
    LOG_SYSERR << "PollPoller::poll()";
  }
  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);
    }
  }
}

void PollPoller::updateChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  LOG_TRACE << "fd = " << channel->fd() << " events = " << channel->events();
  // index < 0说明是一个新的通道
  // a new one, add to pollfds_
  if (channel->index() < 0)
  {
    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.events = static_cast<short>(channel->events());
    pfd.revents = 0;
	// 将一个通道暂时更改为不关注事件，但不从Poller中移除该通道
    if (channel->isNoneEvent())
    {
      // ignore this pollfd
	  // 暂时忽略该文件描述符的事件
	  // 这里pfd.fd 可以直接设置为-1
      pfd.fd = -channel->fd()-1;	// 这样子设置是为了removeChannel优化
    }
  }
}

void PollPoller::removeChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  LOG_TRACE << "fd = " << channel->fd();
  assert(channels_.find(channel->fd()) != channels_.end());
  assert(channels_[channel->fd()] == channel);
  assert(channel->isNoneEvent());
  int idx = channel->index();
  assert(0 <= idx && idx < static_cast<int>(pollfds_.size()));
  const struct pollfd& pfd = pollfds_[idx]; (void)pfd;
  assert(pfd.fd == -channel->fd()-1 && pfd.events == channel->events());
  size_t n = channels_.erase(channel->fd());
  assert(n == 1); (void)n;
  if (implicit_cast<size_t>(idx) == pollfds_.size()-1)
  {
    pollfds_.pop_back();
  }
  else
  {
	// 这里移除的算法复杂度是O(1)，将待删除元素与最后一个元素交换再pop_back
    int channelAtEnd = pollfds_.back().fd;
    iter_swap(pollfds_.begin()+idx, pollfds_.end()-1);
    if (channelAtEnd < 0)
    {
      channelAtEnd = -channelAtEnd-1;
    }
    channels_[channelAtEnd]->set_index(idx);
    pollfds_.pop_back();
  }
}

3.EPollPoller类

数据成员：

static const int kInitEventListSize = 16：能够容纳的事件个数
int epollfd_：epoll_create()的返回值
EventList events_：事件列表events_
ChannelMap channels_：所关注的通道列表channels_

typedef

typedef std::vector EventList;
typedef std::map<int, Channel*> ChannelMap;

成员函数：

EPollPoller(EventLoop* loop)：构造函数，调用Poller类的构造函数Poller(loop)初始化Poller所属EventLoop，即ownerLoop_
virtual ~EPollPoller()：析构函数
virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels)：poll()填充活动通道的列表activeChannels，返回当前时间
virtual void updateChannel(Channel* channel)：updateChannel()用于注册或者更新通道所关注的事件
virtual void removeChannel(Channel* channel)：removeChannel()用于移除通道所关注的事件
void fillActiveChannels(int numEvents,ChannelList* activeChannels) const：poll()调用fillActiveChannels()，在activeChannels中放入numEvents个活动通道
void update(int operation, Channel* channel)：updateChannel()调用update()注册或者更新通道所关注的事件

EPollPoller.h

#ifndef MUDUO_NET_POLLER_EPOLLPOLLER_H
#define MUDUO_NET_POLLER_EPOLLPOLLER_H

#include <muduo/net/Poller.h>

#include <map>
#include <vector>

struct epoll_event;

namespace muduo
{
namespace net
{

///
/// IO Multiplexing with epoll(4).
///
class EPollPoller : public Poller
{
 public:
  EPollPoller(EventLoop* loop);
  virtual ~EPollPoller();
  
  //poll()填充活动通道的列表activeChannels，返回当前时间
  virtual Timestamp poll(int timeoutMs, ChannelList* activeChannels);
  //updateChannel()用于注册或者更新通道所关注的事件
  virtual void updateChannel(Channel* channel);
  //removeChannel()用于移除通道所关注的事件
  virtual void removeChannel(Channel* channel);

 private:
  //能够容纳的事件个数
  static const int kInitEventListSize = 16;
  
  //poll()调用fillActiveChannels()，在activeChannels中放入numEvents个活动通道
  void fillActiveChannels(int numEvents,
                          ChannelList* activeChannels) const;
  //updateChannel()调用update()注册或者更新通道所关注的事件
  void update(int operation, Channel* channel);

  typedef std::vector<struct epoll_event> EventList;
  typedef std::map<int, Channel*> ChannelMap;
  
  //epoll_create()的返回值
  int epollfd_;
  //事件列表events_
  EventList events_;
  //所关注的通道列表channels_
  ChannelMap channels_;
};

}
}
#endif  // MUDUO_NET_POLLER_EPOLLPOLLER_H

EPollPoller.cc

#include <muduo/net/poller/EPollPoller.h>

#include <muduo/base/Logging.h>
#include <muduo/net/Channel.h>

#include <boost/static_assert.hpp>

#include <assert.h>
#include <errno.h>
#include <poll.h>
#include <sys/epoll.h>

using namespace muduo;
using namespace muduo::net;

// On Linux, the constants of poll(2) and epoll(4)
// are expected to be the same.
BOOST_STATIC_ASSERT(EPOLLIN == POLLIN);
BOOST_STATIC_ASSERT(EPOLLPRI == POLLPRI);
BOOST_STATIC_ASSERT(EPOLLOUT == POLLOUT);
BOOST_STATIC_ASSERT(EPOLLRDHUP == POLLRDHUP);
BOOST_STATIC_ASSERT(EPOLLERR == POLLERR);
BOOST_STATIC_ASSERT(EPOLLHUP == POLLHUP);

namespace
{
const int kNew = -1;
const int kAdded = 1;
const int kDeleted = 2;
}

EPollPoller::EPollPoller(EventLoop* loop)
  : Poller(loop),
    epollfd_(::epoll_create1(EPOLL_CLOEXEC)),
    events_(kInitEventListSize)
{
  if (epollfd_ < 0)
  {
    LOG_SYSFATAL << "EPollPoller::EPollPoller";
  }
}

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

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)
  {
    LOG_TRACE << numEvents << " events happended";
    fillActiveChannels(numEvents, activeChannels);
    if (implicit_cast<size_t>(numEvents) == events_.size())
    {
      events_.resize(events_.size()*2);
    }
  }
  else if (numEvents == 0)
  {
    LOG_TRACE << " nothing happended";
  }
  else
  {
    LOG_SYSERR << "EPollPoller::poll()";
  }
  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);
#ifndef NDEBUG
    int fd = channel->fd();
    ChannelMap::const_iterator it = channels_.find(fd);
    assert(it != channels_.end());
    assert(it->second == channel);
#endif
    channel->set_revents(events_[i].events);
    activeChannels->push_back(channel);
  }
}

void EPollPoller::updateChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  LOG_TRACE << "fd = " << channel->fd() << " events = " << channel->events();
  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)
    {
      assert(channels_.find(fd) == channels_.end());
      channels_[fd] = channel;
    }
    else // index == kDeleted
    {
      assert(channels_.find(fd) != channels_.end());
      assert(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();
    (void)fd;
    assert(channels_.find(fd) != channels_.end());
    assert(channels_[fd] == channel);
    assert(index == kAdded);
    if (channel->isNoneEvent())
    {
      update(EPOLL_CTL_DEL, channel);
      channel->set_index(kDeleted);
    }
    else
    {
      update(EPOLL_CTL_MOD, channel);
    }
  }
}

void EPollPoller::removeChannel(Channel* channel)
{
  Poller::assertInLoopThread();
  int fd = channel->fd();
  LOG_TRACE << "fd = " << fd;
  assert(channels_.find(fd) != channels_.end());
  assert(channels_[fd] == channel);
  assert(channel->isNoneEvent());
  int index = channel->index();
  assert(index == kAdded || index == kDeleted);
  size_t n = channels_.erase(fd);
  (void)n;
  assert(n == 1);

  if (index == kAdded)
  {
    update(EPOLL_CTL_DEL, channel);
  }
  channel->set_index(kNew);
}

void EPollPoller::update(int operation, Channel* channel)
{
  struct epoll_event event;
  bzero(&event, sizeof event);
  event.events = channel->events();
  event.data.ptr = channel;
  int fd = channel->fd();
  if (::epoll_ctl(epollfd_, operation, fd, &event) < 0)
  {
    if (operation == EPOLL_CTL_DEL)
    {
      LOG_SYSERR << "epoll_ctl op=" << operation << " fd=" << fd;
    }
    else
    {
      LOG_SYSFATAL << "epoll_ctl op=" << operation << " fd=" << fd;
    }
  }
}
asp.net+jquery长轮询实例
08-02
完整长轮询代码，客户端使用jquery访问后台程序，后台hold住此连接，实时监控数据变化，有变化则返回结果到客户端。此代码使用了异步回调以保证主进程不会形成阻塞。
asp.net ajax 轮询,ASP.NET 中长轮询的实现
weixin_39568926的博客
08-06 583
一、.aspx 的 @Page 指令上加上Async="true"比如：二、.aspx.cs 页面写类似如下代码public partial class LiveMessageList : System.Web.UI.Page{protected QueryTask Task { get; set; }protected void Page_Load(object sender, EventAr...
ASP.NET实现HTTP长轮询（二）——一般处理程序ashx
aoselei6295的博客
06-10 440
本文主要描述如何在ASP.NET一般处理程序中实现长轮询： （1）实现IAsyncResult： using System; using System.Threading; using System.Web; public class LongPollingAsyncResult : IAsyncResult { publi...
Poller模块 --- 事件监控模块
weixin_64099089的博客
10-12 593
Poller模块，对epoll的操作进行封装以及管理
Tomcat NIO(8)-Poller线程的阻塞与唤醒
weixin_46073333的博客
09-05 865
在上一篇文章里我们主要介绍了 tomcat NIO 中的poller线程，包括启动 poller 线程，添加事件到事件队列，对原始 socket 注册事件和 poller 线程的核...
网络轮询器 NetPoller
choice~的博客
07-28 681
网络轮询器是 Go 语言运行时用来处理 I/O 操作的关键组件，它使用了操作系统提供的 I/O 多路复用机制增强程序的并发处理能力。网络轮询器不仅用于监控网络 I/O，还能用于监控文件的 I/O，它利用了操作系统提供的 I/O 多路复用模型来提升 I/O 设备的利用率以及程序的性能。
ASP.NET实现HTTP长轮询（一）——WebForm
竹林之风
06-10 2724
本文主要描述如何在ASP.NET WebForm中实现长轮询： （1）在ASP.NET WebForm的aspx文件中设置如下指令即可实现异步的ASP.NET WebForm： <%@PageLanguage="C#"AutoEventWireup="true"CodeBehind="LongPolling.aspx.cs"Inherits="LongPoll...
用.NET MVC实现长轮询，与jQuery.AJAX即时双向通信
萌萌的It人 www.itmmd.com
07-27 6098
两周前用长轮询做了一个Chat，并移植到了Azure，还写了篇博客http://www.cnblogs.com/indream/p/3187540.html，让大家帮忙测试。 首先感谢300位注册用户，让我有充足的数据进行重构和优化。所以这两周都在进行大重构。 其中最大的一个问题就是数据流量过大，原先已有更新，还会有Web传统“刷新”的形式把数据重新拿一次，然后再替换掉本地数据。 但这一拿问
ASP.NET实现HTTP长轮询（四）——WebApi
竹林之风
06-10 2375
本文主要描述如何在ASP.NET WebApi中实现长轮询： （1）控制器： usingSystem; usingSystem.Web.Http; usingSystem.Threading.Tasks; usingSystem.Threading; publicclassLongPollingController:ApiController { ...
Poller
最新发布
qq_47987543的博客
10-28 590
Poller API 是对 epoll I/O 多路复用机制的封装，核心功能包括监控文件描述符事件、更新和移除 Channel。通过 kNew/kAdded/kDeleted 三种状态管理 Channel 生命周期，确保正确的 epoll_ctl 调用。调用流程包括初始化、事件循环中的 poll 操作以及 Channel 的增删改查。状态机设计避免了重复操作和非法调用，提高了系统健壮性。整个机制为事件驱动模型提供了高效可靠的底层支持。
【Poller/EPollPoller】
b_i_n_03的博客
06-05 649
摘要：muduo网络库中的Poller采用抽象虚类设计，由EpollPoller和PollPoller具体实现。EpollPoller封装了epoll系统调用，通过ChannelMap管理监听对象，用epoll_event结构体数组存储活跃事件。核心机制包括：1）poll方法调用epoll_wait监听事件；2）fillActiveChannels将事件转换为Channel对象；3）通过ptr指针实现事件与Channel的高效绑定。设计亮点包括：vector容器自动扩容、Channel状态管理、类型安全转换
一句话讲懂：muduo网络库——Poller
empty_me的博客
12-19 434
起到一个吸引读者的作用
WorkFlow学习分享:poller与mpoller
qq_60328455的博客
10-04 742
poller，主要理解结点插入，定时器，异步的开启，epoll唤醒后读写分支的操作还需要往后解密
【长文梳理webserver核心】核心类篇
weixin_45962681的博客
10-10 1086
有三个核心组件支撑一个reactor实现 [] 的 [] 一组fd，并根据每个fd上发生的事件 [调用] 相应的处理函数。这三个组件就是 EventLoop 、Channel 以及 Poller 三个类，其中 EventLoop 可以看作是对业务线程的封装，而 Channel 可以看作是对每个已经建立连接的封装（即accept(3) 返回的文件描述符）
Golang源码探究 —— 网络轮询器netpoller
Peerless__的博客
10-12 2770
网络通信是服务端程序必不可少也是至关重要的一部分，基于TCP Socket的通信则是网络编程的主流。TCP Socket是最常见的网络编程，在POSIX标准发布后，Socket得到了各大主流操作系统平台很好的支持。 Go是自带运行时的跨平台编程语言，Go的net包中暴露给开发者的Socket也是建立在操作系统原生socket接口之上的。netpoller是Go语言用来屏蔽各个操作系统底层高效I/O多路复用的网络轮询器，它屏蔽了各个操作系统底层不同而且复杂的I/O多路复用的使用，在上层为我们提
Promise-Poller：基于Promise的轮询工具
gitblog_00743的博客
01-12 320
Promise-Poller：基于Promise的轮询工具 1. 项目基础介绍 Promise-Poller是一个基于Promise的轮询工具，使用JavaScript编程语言编写。该项目的目的是帮助开发者处理异步操作，这些操作可能会失败，需要重试多次才能成功。Promise-Poller通过Promise机制优雅地处理这种情况。 2. 核心功能 任务函数：Promise-Poller的核心是一...
Mudu分析及总结（三）Poller、PollPoller
蜗牛，为梦想而生。
05-27 1567
Poller是基类，PollPoller和EPollPoller是子类，本文只介绍Poller和PollPoller。 Poller操作Channel对象，但是不拥有Channel对象。 PollPoller是基于poll实现，EPollPoller是基于epoll实现。 一、类关系图 二、工作时序图 三、poll方法基本概念 1、poll() int poll (struct pollf...
.net定时任务(作业)-简单说
Osborn的博客
07-27 8945
我要给大家介绍一个开源的作业调度框架Quartz.NET, 有一些工作需要定时轮询数据库同步，定时邮件通知，定时处理数据 可以选择Quartz.NET。 快速搭建一个Quartz 1.创建一个控制台应用程序 2.安装依赖包（类库） Install-Package QuartzInstall-Package Common.Logging.Log4Net1211Insta
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值