golang netpoller揭秘

最新推荐文章于 2024-07-28 22:28:43 发布
最新推荐文章于 2024-07-28 22:28:43 发布
阅读量696 收藏 15
点赞数 24
分类专栏： lang net 文章标签： golang 开发语言 后端 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iUcool/article/details/138285983
版权
lang 同时被 2 个专栏收录
36 篇文章 0 订阅
订阅专栏
net
14 篇文章 1 订阅
订阅专栏
文章详细阐述了Go语言中的golangnetpoller，它是基于Linux的epoll、BSD的kqueue或Windows的IOCP等事件通知机制，用于监控网络套接字的I/O操作。文章介绍了netFD和pollDesc数据结构，以及如何通过netpoll实现异步网络编程，强调了Go语言中goroutine管理对简化网络编程的重要性。
摘要由CSDN通过智能技术生成

golang netpoller是网络IO模型的核心部分，利用了操作系统提供的事件通知机制，如Linux的epoll、BSD的kqueue或者windows的IOCP。这些机制允许应用程序监视多个文件描述符（在网络编程中，通常是 socket），并在其中任何一个准备好进行 I/O 操作时接收通知。

数据结构

netFD

网络连接都是基于对netFD结构的操作

// 网络文件描述符
type netFD struct {
	pfd poll.FD

	// immutable until Close
  // 网络协议族。比如AF_INET表示ipv4，AF_INET6表示ipv6
	family      int
  // socket类型
	sotype      int
  // 握手是否完成
	isConnected bool // handshake completed or use of association with peer
  // 网络类型。比如tcp、ip
	net         string
  // 储存网络连接的本地地址
	laddr       Addr
  // 储存网络连接的远程地址
	raddr       Addr
}

// 文件描述符。可表示网络连接或者系统文件
type FD struct {
	// 用于锁定文件描述符并序列化 Read 和 Write 方法的使用。
	fdmu fdMutex

	// 系统文件描述符。这个字段的值在 Close 方法调用之前是不变的。
	Sysfd int

	// 文件描述符的平台相关状态。
	SysFile

	// I/O 轮询器
	pd pollDesc

	// 文件关闭时发出的信号量
	csema uint32

  // 非0代表处于堵塞模式
	isBlocking uint32

	// 是否是一个流式描述符，而不是一个基于数据包的描述符，如 UDP 套接字。这个字段的值是不变的。
	IsStream bool

	// 零字节读取是否表示 EOF。对于基于消息的套接字连接，这个字段的值是 false。
	ZeroReadIsEOF bool

	// 表示这是否是一个文件，而不是一个网络套接字。
	isFile bool
}

pollDesc

pollDesc为底层轮询器封装

type pollDesc struct {
	runtimeCtx uintptr
}

type pollDesc struct {
	_     sys.NotInHeap
  // 下一个pollDesc
	link  *pollDesc      // in pollcache, protected by pollcache.lock
  // 文件描述符
	fd    uintptr        // constant for pollDesc usage lifetime
  // 保护pollDesc不受过时的的影响
	fdseq atomic.Uintptr // protects against stale pollDesc

  // 保存从 closing、rd 和 wd 中获取的位，这些位只在持有锁的情况下写入，以供 netpollcheckerr 使用，netpollcheckerr 不能获取锁。在可能改变摘要的方式下锁定这些字段后，代码必须在释放锁之前调用 publishInfo。
	atomicInfo atomic.Uint32 // atomic pollInfo

	// 读取和写入的G 指针，它们是原子访问的
	rg atomic.Uintptr // pdReady, pdWait, G waiting for read or pdNil
	wg atomic.Uintptr // pdReady, pdWait, G waiting for write or pdNil

	lock    mutex // protects the following fields
  // 表示是否正在关闭
	closing bool
  // 用户可设置的cookie
	user    uint32    
  
  // 保护读写计时器不受过时的影响
	rseq    uintptr   // protects from stale read timers
  wseq    uintptr   // protects from stale write timers
  
  // 读截止timer
	rt      timer     // read deadline timer (set if rt.f != nil)
  // 读截止时间
	rd      int64     // read deadline (a nanotime in the future, -1 when expired)
  // 写截止timer
	wt      timer     // write deadline timer
  // 写截止时间
	wd      int64     // write deadline (a nanotime in the future, -1 when expired)
  
  // 指向pollDesc自身的指针，用于间接接口的储存
	self    *pollDesc
}
pollCache

pollCache用于缓存pollDesc结构，可以避免在每次网络IO操作时都创建新的pollDesc

type pollCache struct {
  // 互斥锁，用于在多个 goroutine 之间同步对 pollCache 的访问
	lock  mutex
  // 指向 pollDesc 的指针，表示缓存中的第一个 pollDesc 结构。如果缓存为空，那么这个字段的值就是nil
	first *pollDesc
}

PollDesc 对象必须是类型稳定的，因为在描述符关闭或重用后，我们可能会从 epoll/kqueue 中获取到就绪通知。这是因为在网络编程中，文件描述符（File Descriptor，简称 FD）是一个重要的资源，它在关闭后可能会被立即重用。如果一个 FD 关闭后，另一个 FD 立即重用了这个数字，那么原来的 FD 上的任何未决的事件可能会错误地通知到新的 FD 上。

使用 seq 变量来检测过时的通知。在改变截止日期或者描述符被重用时，seq 会增加。这是为了防止因为 FD 的重用导致的错误通知。通过在每次改变 FD 的状态时增加 seq，可以确保即使 FD 被重用，也能正确地识别出哪些通知是过时的

监听

net.Listen

调用net.Listen之后会通过系统调用socket方法创建网络socket分配给listener

// socket returns a network file descriptor that is ready for
// asynchronous I/O using the network poller.
func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) (fd *netFD, err error) {
  // 创建系统socket
	s, err := sysSocket(family, sotype, proto)
	if err != nil {
		return nil, err
	}
  
  // 设置默认的socket选项
	if err = setDefaultSockopts(s, family, sotype, ipv6only); err != nil {
		poll.CloseFunc(s)
		return nil, err
	}
  
  // 创建新的网络文件描述符
	if fd, err = newFD(s, family, sotype, net); err != nil {
		poll.CloseFunc(s)
		return nil, err
	}

  // 若本地地址存在，远程地址不存在，则为监听。根据socket类型，调用网络文件描述符方法进行监听
	if laddr != nil && raddr == nil {
		switch sotype {
		case syscall.SOCK_STREAM, syscall.SOCK_SEQPACKET:
			if err := fd.listenStream(ctx, laddr, listenerBacklog(), ctrlCtxFn); err != nil {
				fd.Close()
				return nil, err
			}
			return fd, nil
		case syscall.SOCK_DGRAM:
			if err := fd.listenDatagram(ctx, laddr, ctrlCtxFn); err != nil {
				fd.Close()
				return nil, err
			}
			return fd, nil
		}
	}
  
  // 否则，为dial请求
	if err := fd.dial(ctx, laddr, raddr, ctrlCtxFn); err != nil {
		fd.Close()
		return nil, err
	}
  
	return fd, nil
}

netFD.listenStream

netFD.listenStream创建socket，并绑定监听地址进行监听

func (fd *netFD) listenStream(ctx context.Context, laddr sockaddr, backlog int, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) error {
  // 设置默认的监听socket选项
	var err error
	if err = setDefaultListenerSockopts(fd.pfd.Sysfd); err != nil {
		return err
	}
  
  // 获取socket地址
	var lsa syscall.Sockaddr
	if lsa, err = laddr.sockaddr(fd.family); err != nil {
		return err
	}

  // 执行控制操作
	if ctrlCtxFn != nil {
		c := newRawConn(fd)
		if err := ctrlCtxFn(ctx, fd.ctrlNetwork(), laddr.String(), c); err != nil {
			return err
		}
	}

  // 将socket绑定到指定地址
	if err = syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
		return os.NewSyscallError("bind", err)
	}
  
  // 开始监听
	if err = listenFunc(fd.pfd.Sysfd, backlog); err != nil {
		return os.NewSyscallError("listen", err)
	}
  
  // 网络描述符初始化，注册到netpoller中
	if err = fd.init(); err != nil {
		return err
	}
  
  // 获取socket本地网络地址，并设置到fd本地地址中
	lsa, _ = syscall.Getsockname(fd.pfd.Sysfd)
	fd.setAddr(fd.addrFunc()(lsa), nil)
	return nil
}

poll_runtime_pollOpen

在网络描述符初始化中，会调用poll_runtime_pollOpen打开文件描述符，并注册到netpoller中

func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
  // 从缓存中分配到pollDesc
	pd := pollcache.alloc()
	lock(&pd.lock)
  
  // 初始化分配到的pollDesc
	wg := pd.wg.Load()
	if wg != pdNil && wg != pdReady {
		throw("runtime: blocked write on free polldesc")
	}
	rg := pd.rg.Load()
	if rg != pdNil && rg != pdReady {
		throw("runtime: blocked read on free polldesc")
	}
	pd.fd = fd
	if pd.fdseq.Load() == 0 {
		// The value 0 is special in setEventErr, so don't use it.
		pd.fdseq.Store(1)
	}
	pd.closing = false
	pd.setEventErr(false, 0)
	pd.rseq++
	pd.rg.Store(pdNil)
	pd.rd = 0
	pd.wseq++
	pd.wg.Store(pdNil)
	pd.wd = 0
	pd.self = pd
  
  // 更新pollDesc的原子信息
	pd.publishInfo()
	unlock(&pd.lock)

  // 将文件描述符注册到netpoller
	errno := netpollopen(fd, pd)
	if errno != 0 {
		pollcache.free(pd)
		return nil, int(errno)
	}
	return pd, 0
}

netpollopen将pollDesc注册到Linux epoll中

func netpollopen(fd uintptr, pd *pollDesc) uintptr {
	var ev syscall.EpollEvent
  // 设置事件为输入、输出、连接被对方关闭或者半关闭事件以及设置边缘触发模式
	ev.Events = syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP | syscall.EPOLLET
  // 将 pd 和 pd.fdseq.Load() 打包成一个标记指针 tp。这个标记指针被存储在 ev.Data 中
	tp := taggedPointerPack(unsafe.Pointer(pd), pd.fdseq.Load())
	*(*taggedPointer)(unsafe.Pointer(&ev.Data)) = tp
  // 将 fd 添加到 epoll 的实例中，并返回 syscall.EpollCtl 的结果。syscall.EpollCtl 是一个系统调用，用于控制 epoll 的行为。在这里，它的行为是添加一个新的文件描述符到 epoll 的实例中
	return syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, int32(fd), &ev)
}

接收

listener.Accept

listener.Accept实质上就是调用其内部的netFD的accept方法，接受网络连接，并以建立的新连接创建网络文件描述符

func (fd *netFD) accept() (netfd *netFD, err error) {
	// 接受新的网络连接，并返回新的系统文件描述符d和远程socket地址 rsa
  d, rsa, errcall, err := fd.pfd.Accept()
	if err != nil {
		if errcall != "" {
			err = wrapSyscallError(errcall, err)
		}
		return nil, err
	}

  // 根据建立连接的系统文件描述符，创建新的网络文件描述符
	if netfd, err = newFD(d, fd.family, fd.sotype, fd.net); err != nil {
		poll.CloseFunc(d)
		return nil, err
	}
  
  // 初始化新网络文件描述符
	if err = netfd.init(); err != nil {
		netfd.Close()
		return nil, err
	}
  
  // 获取新网络文件描述符的本地socket地址，并设置到fd本地地址中
	lsa, _ := syscall.Getsockname(netfd.pfd.Sysfd)
	netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))
	return netfd, nil
}

fd.Accept

fd.Accept与下面fd.Read大致流程一致，只是循环调用的是accept

func (fd *FD) Accept() (int, syscall.Sockaddr, string, error) {
	if err := fd.readLock(); err != nil {
		return -1, nil, "", err
	}
	defer fd.readUnlock()

	if err := fd.pd.prepareRead(fd.isFile); err != nil {
		return -1, nil, "", err
	}
	for {
		s, rsa, errcall, err := accept(fd.Sysfd)
		if err == nil {
			return s, rsa, "", err
		}
		switch err {
		case syscall.EINTR:
			continue
		case syscall.EAGAIN:
			if fd.pd.pollable() {
				if err = fd.pd.waitRead(fd.isFile); err == nil {
					continue
				}
			}
		case syscall.ECONNABORTED:
			// This means that a socket on the listen
			// queue was closed before we Accept()ed it;
			// it's a silly error, so try again.
			continue
		}
		return -1, nil, errcall, err
	}
}

读取

fd.Read

主要就是加锁，尝试从文件描述符中读取数据，若读取不成功，就进行读取等待

func (fd *FD) Read(p []byte) (int, error) {
  // 获取读锁
	if err := fd.readLock(); err != nil {
		return 0, err
	}
	defer fd.readUnlock()
  
  // 若读取字节长度为0，直接返回
	if len(p) == 0 {
		return 0, nil
	}
  
  // 准备读取
	if err := fd.pd.prepareRead(fd.isFile); err != nil {
		return 0, err
	}
  
  // 若fd是流，且读取字节长度大于1<<30，则截断
	if fd.IsStream && len(p) > maxRW {
		p = p[:maxRW]
	}
  
	for {
    // 系统调用从文件描述符中读取数据
		n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)
		if err != nil {
			n = 0
      // 若读未就绪时，等待
			if err == syscall.EAGAIN && fd.pd.pollable() {
				if err = fd.pd.waitRead(fd.isFile); err == nil {
					continue
				}
			}
		}
		err = fd.eofError(n, err)
		return n, err
	}
}

在读取信息未到达时，waitRead方法会调用到runtime_pollWait方法，而runtime_pollWait又会调用netpollblock方法

netpollblock

netpollblock用于堵塞当前goroutine，等待网络IO事件的发生

// 对于同一个模式，不允许并发调用netpollblock，因为 pollDesc 只能为每种模式持有一个等待的 goroutine
func netpollblock(pd *pollDesc, mode int32, waitio bool) bool {
  // 根据读写模式，获取状态
	gpp := &pd.rg
	if mode == 'w' {
		gpp = &pd.wg
	}

	// set the gpp semaphore to pdWait
	for {
    // 若期待的IO事件准备好了，则解除堵塞
		if gpp.CompareAndSwap(pdReady, pdNil) {
			return true
		}
    
    // 若没有期待的IO事件发生，则设置为等待，退出循环
		if gpp.CompareAndSwap(pdNil, pdWait) {
			break
		}

		// 防止出现意外状态，导致无限循环
		if v := gpp.Load(); v != pdReady && v != pdNil {
			throw("runtime: double wait")
		}
	}

  // 若设置了忽略错误等待或者无错误，则堵塞
  // 在将 gpp 设置为 pdWait 后需要重新检查错误状态。因为 runtime_pollUnblock、runtime_pollSetDeadline 和 deadlineimpl 这几个函数的操作顺序与此相反：它们先将状态存储到 closing/rd/wd，然后发布信息，最后加载 rg/wg。所以，为了保证状态的正确性，需要在设置 gpp 为 pdWait 后重新检查错误状态
	if waitio || netpollcheckerr(pd, mode) == pollNoError {
		gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceBlockNet, 5)
	}
	
  // 堵塞结束后，设置pdNil状态
	old := gpp.Swap(pdNil)
	if old > pdWait {
		throw("runtime: corrupted polldesc")
	}
  
	return old == pdReady
}

netpoll

netpoll检测所有就绪的网络连接，并返回所有可允许的goroutine。因此，通过该方法可以唤醒在网络读取、写入等待中的goroutine

func netpoll(delay int64) (gList, int32) {
	if epfd == -1 {
		return gList{}, 0
	}
  
  // 根据输入的延迟时间，计算epoll等待时间
  // 等待时间delay < 0，永远堵塞下去
  // 等待时间delay = 0，非堵塞，仅轮询
  // 等待时间delay > 0，堵塞若干时间
	var waitms int32
	if delay < 0 {
		waitms = -1
	} else if delay == 0 {
		waitms = 0
	} else if delay < 1e6 {
		waitms = 1
	} else if delay < 1e15 {
		waitms = int32(delay / 1e6)
	} else {
		// An arbitrary cap on how long to wait for a timer.
		// 1e9 ms == ~11.5 days.
		waitms = 1e9
	}
  
  // 调用epollWait，等待epoll事件
	var events [128]syscall.EpollEvent
retry:
	n, errno := syscall.EpollWait(epfd, events[:], int32(len(events)), waitms)
	if errno != 0 {
		if errno != _EINTR {
			println("runtime: epollwait on fd", epfd, "failed with", errno)
			throw("runtime: netpoll failed")
		}
		// If a timed sleep was interrupted, just return to
		// recalculate how long we should sleep now.
		if waitms > 0 {
			return gList{}, 0
		}
		goto retry
	}
  
  // 遍历事件，获取需要恢复的goroutine
	var toRun gList
	delta := int32(0)
	for i := int32(0); i < n; i++ {
		ev := events[i]
		if ev.Events == 0 {
			continue
		}

    // 如果设置了提前唤醒，则会跳出当前轮询。因为break事件只是表示有其他事情需要处理，并不是真正的网络事件
		if *(**uintptr)(unsafe.Pointer(&ev.Data)) == &netpollBreakRd {
			if ev.Events != syscall.EPOLLIN {
				println("runtime: netpoll: break fd ready for", ev.Events)
				throw("runtime: netpoll: break fd ready for something unexpected")
			}
      
      // 如果 delay 不为 0，这表示这个 "break" 事件是在一个阻塞的轮询中被检测到的。在这种情况下，代码会从 netpollBreakRd 读取数据，并将 netpollWakeSig 设置为 0。这样可以确保下一次 "break" 事件能够被正确处理。
			if delay != 0 {
				var tmp [16]byte
				read(int32(netpollBreakRd), noescape(unsafe.Pointer(&tmp[0])), int32(len(tmp)))
				netpollWakeSig.Store(0)
			}
			continue
		}

    // 判断事件发生的类型，以决定从pollDesc中wg还是rg取goroutine
		var mode int32
		if ev.Events&(syscall.EPOLLIN|syscall.EPOLLRDHUP|syscall.EPOLLHUP|syscall.EPOLLERR) != 0 {
			mode += 'r'
		}
		if ev.Events&(syscall.EPOLLOUT|syscall.EPOLLHUP|syscall.EPOLLERR) != 0 {
			mode += 'w'
		}
		if mode != 0 {
      // 取出保存在事件数据中的pollDes，并添加到就绪goroutine链表
			tp := *(*taggedPointer)(unsafe.Pointer(&ev.Data))
			pd := (*pollDesc)(tp.pointer())
			tag := tp.tag()
			if pd.fdseq.Load() == tag {
				pd.setEventErr(ev.Events == syscall.EPOLLERR, tag)
				delta += netpollready(&toRun, pd, mode)
			}
		}
	}
	return toRun, delta
}

总结

netpoller依托于go调度器，提供了一种看上去同步的异步网络编程模式，显著地降低了开发难度

更重要的是，go主动挂起goroutine等待网络IO的完成，而不是被动让系统线程去挂起，这就将执行网络IO的goroutine掌控在Go运行时中

Ref

  1. https://strikefreedom.top/archives/go-netpoll-io-multiplexing-reactor
Golang代码笔记--netpoller
villare的博客
10-17 920
netpoller 背景介绍 I/O多路复用模型（I/O Multiplexing）: select 阻塞，直到有FD准备好，FD数量有FD_SETSIZE限制 int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); // readfds,write...
golang实现海康相机抓拍demo
04-30
golang 实现海康相机抓拍，目前只支持球机。需要在代码中设置用户名和密码。 如何调试？用vscode打开，安装golang插件，即可直接调试运行。 编译与运行：运行go build命令，将HKnet.exe拷贝到build\Windows下，运行...
Golang源码探究 —— 网络轮询器netpoller
Peerless__的博客
10-12 2275
网络通信是服务端程序必不可少也是至关重要的一部分，基于TCP Socket的通信则是网络编程的主流。TCP Socket是最常见的网络编程，在POSIX标准发布后，Socket得到了各大主流操作系统平台很好的支持。 Go是自带运行时的跨平台编程语言，Go的net包中暴露给开发者的Socket也是建立在操作系统原生socket接口之上的。netpoller是Go语言用来屏蔽各个操作系统底层高效I/O多路复用的网络轮询器，它屏蔽了各个操作系统底层不同而且复杂的I/O多路复用的使用，在上层为我们提
GoLang NetPoll 实现分析
程序创坊
05-09 570
Go netpoller 通过在底层对 epoll/kqueue/iocp 的封装，从而实现了使用同步编程模式达到异步执行的效果
Go Netpoller
JunChow
02-25 229
传统的网络服务设计模式中有两种，一种是多线程，一种是线程池。 对于多线程模式，也就是来了客户端服务器就会新建一个线程来处理该客户端的读写事件。由于服务器会为每个连接新建一个线程来处理，资源占用会非常大。因此当连接数量达到上限时，再有用户请求连接到来将直接导致资源瓶颈，严重的可能会导致服务器崩溃。 为了解决一个线程对应一个客户端连接模式带来的问题，后来提出了线程池的方式，也就是创建一个固定大小的线程...
详解golang net之netpoll
weixin_30781433的博客
09-20 1318
golang版本1.12.9；操作系统：readhat 7.4 golang的底层使用epoll来实现IO复用。netPoll通过pollDesc结构体将文件描述符与底层进行了绑定。netpoll实现了用户层面的与底层网络IO相关的goroutine的阻塞/非阻塞管理。 对netpoll的介绍按照这篇文章的思路按照tcp建链中的listen/accept/read/write/clo...
简单的Golang SCSI Target框架-Golang开发
05-26
gotgt gotgt项目是使用golang实现的简单SCSI Target框架，旨在提高性能和密度。 简而言之，可以将这个iSCSI / SCSI Target Go实现作为一个库包含/导入，以允许上层的gotgt gotgt项目是一个简单的SCSI Target框架，以...
golang中文手册_golang中文手册_goapiCHM_golang中文手册.chm_
10-02
Go语言，又称Golang，是由Google开发的一种静态类型、编译型、并发型且具有垃圾回收功能的编程语言。它设计的目标是提高开发者的生产效率，同时保持系统级编程的性能。Go语言的设计受到了C、 Pascal、 Miranda和...
使用Golang qt后端以Golang编写的Neovim GUI-Golang开发
05-26
GoNeovim是用Go编写的Neovim GUI，对Go使用Qt绑定。 该存储库是从原始Gonvim派生出来的，用于维护和增强。 功能所有功能都是可选的。 您可以使用i GoNeovim是用Go编写的Neovim GUI，对Go使用Qt绑定。...
Golang中的实时视频流服务器-Golang开发
05-26
纯Golang，高性能和跨平台； 支持常用的传输协议，文件格式和编码格式； 简单高效的直播服务器：安装和使用非常简单； 纯Golang，高性能和跨平台； 支持常用的传输协议，文件格式和编码格式； 支持的传输协议RTMP ...
谈谈golang的netpoll原理(二)
恋恋风辰的技术博客
05-20 1307
接上文我们查看了bind和listen流程，直到了listen操作会在内核初始化一个epoll表，并将listen的描述符加入到epoll表中 如何保证epoll表初始化一次 前文我们看到pollDesc的init函数中调用了runtime的pollOpen函数完成的epoll创建和描述符加入，这里再贴一次代码 func (pd *pollDesc) init(fd *FD) error { serverInit.Do(runtime_pollServerInit) ctx, errno :=
golang中的网络轮询器netpoll源码解析
猛犸象
11-24 881
golang中的网络轮询器netpoll源码解析
浅谈 go netpoll
qq_42461373的博客
06-04 599
1.先谈epoll https://zhuanlan.zhihu.com/p/64746509 1.1 epoll定义 是I/O多路复用的一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪，就是这个文件描述符进行读写操作之前），能够通知程序进行相应的读写操作。 Level_triggered(水平触发)：当被监控的文件描述符上有可读写事件发生时，epoll_wait()会通知处理程序去读写。如果这次没有把数据一次性全部读写完(如读写缓冲区太小)，那么下次调用 epoll_wai
聊聊Go语言中的networkpoller工作机制
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
05-22 974
因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。自此我们完整的将Go语言中的networkpoller的设计和源码都分析完成了，希望对你有帮助。方法，就可以看到我们上图所说明的状态修改和协程入队的操作，它通过。当我们和客户端建立连接之后，我们的客户端协程就会调用连接对象的。
网络轮询器 NetPoller
最新发布
choice~的博客
07-28 394
网络轮询器是 Go 语言运行时用来处理 I/O 操作的关键组件，它使用了操作系统提供的 I/O 多路复用机制增强程序的并发处理能力。网络轮询器不仅用于监控网络 I/O，还能用于监控文件的 I/O，它利用了操作系统提供的 I/O 多路复用模型来提升 I/O 设备的利用率以及程序的性能。
深入理解 Golang: 网络编程
不定期更新 Web 开发及机器学习相关博客
07-02 1093
在 Go 中，内部采用结合阻塞模型和多路复用的方法。在这里就不再是线程操作 Socket，而是 Goroutine 协程。每个协程关心一个 Socket 连接：1.在底层使用操作系统的多路复用 IO；2.在协程层次使用阻塞模型。3.阻塞协程时，休眠协程。
Go netpoll大解析
Seekload
04-18 894
开篇之前简单看过一点go原生netpoll，没注意太多细节。最近从头到尾看了一遍，特写篇文章记录下。文章很长，请耐心看完，一定有所收获。内核空间和用户空间在linux中，经常能看到两个词语:User space(用户空间)和Kernel space (内核空间)。简单地说， Kernel space是linux内核运行的空间，User space是用户程序运行的空间。它们...
go编写的netflow _exporter，本地测试代码
运维仙人
12-26 491
【代码】go编写的netflow _exporter，本地测试代码。
flow的采集与分析---clickhouse的简介和安装
weixin_34055787的博客
03-19 909
前言 最近在参与网络flow采集和分析的项目。主要是遵循netflow和sflow协议，完成对防火墙和核心交换机的流量的采集和存储以及后续分析。flow并发量和数据量都比较大，存储是瓶颈。最开始存储到prometheus和之后测试的infulxdb的方案均宣告失败。看来prometheus还是不适合大数据量的处理，如果数据量过大，需要考虑...
【go基础】16.I/O模型与网络轮询器netpoller
lixiaonan0318的博客
03-24 697
一、I/O模型在linux世界中，所有I/O设备被抽象为文件Everything is File，都通过文件操作：open 打开；seek 改变读写位置；read write 读写；close 关闭文件描述符（File descriptor，FD）：用于访问文件或者其他 I/O 资源的抽象句柄，例如：管道或者网络套接字。不同的 I/O 模型会使用不同的方式操作文件描述符。5种I/O模型：同步的阻塞I/O模型非阻塞I/O模型I/O多路复用模型信号驱动I/O模型异步I/O模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值