type pollDesc struct {
	runtimeCtx uintptr
}

//網(wǎng)絡poller描述符
type pollDesc struct {
    //next指針，指向在pollCache鏈表結構中，以下個pollDesc實例。
	link  *pollDesc      
    //指向fd
	fd    uintptr
    //讀事件狀態(tài)標識器，狀態(tài)有四種：
    //1、pdReady：表示讀操作已就緒，等待處理
    //2、pdWait：表示g將要被阻塞等待讀操作就緒，此時還未阻塞
    //3、g：讀操作的g已經(jīng)被阻塞，rg指向阻塞的g實例
    //4、pdNil：空
	rg atomic.Uintptr 
	wg atomic.Uintptr 
    //...
}

type pollCache struct {
	lock  mutex
	first *pollDesc
}

//從pollCache中分配得到一個pollDesc實例
func (c *pollCache) alloc() *pollDesc {
	lock(&c.lock)
    //如果鏈表為空，則進行初始化
	if c.first == nil {
        //pdSize = 248
		const pdSize = unsafe.Sizeof(pollDesc{})
        //4096 / 248 = 16
		n := pollBlockSize / pdSize
		if n == 0 {
			n = 1
		}
        //分配指定大小的內存空間
		mem := persistentalloc(n*pdSize, 0, &memstats.other_sys)
        //完成指定數(shù)量的pollDesc創(chuàng)建
		for i := uintptr(0); i < n; i++ {
			pd := (*pollDesc)(add(mem, i*pdSize))
			pd.link = c.first
			c.first = pd
		}
	}
	pd := c.first
	c.first = pd.link
	lockInit(&pd.lock, lockRankPollDesc)
	unlock(&c.lock)
	return pd
}

//free用于將一個pollDesc放回pollCache
func (c *pollCache) free(pd *pollDesc) {
	//...
	lock(&c.lock)
	pd.link = c.first
	c.first = pd
	unlock(&c.lock)
}

// 啟動 tcp server 代碼示例
func main() {
    //創(chuàng)建TCP端口監(jiān)聽器，涉及以下事件：
    //1：創(chuàng)建socket fd，調用bind和accept系統(tǒng)接口函數(shù)
    //2：調用epoll_create，創(chuàng)建eventpool
    //3：調用epoll_ctl(ADD)，將socket fd注冊到epoll事件表
	l, _ := net.Listen("tcp", ":8080")
	// eventloop reactor 模型
	for {
        //等待TCP連接到達，涉及以下事件：
        //1：循環(huán)+非阻塞調用accept
        //2：若未就緒，則調用gopark進行阻塞
        //3：等待netpoller輪詢喚醒
        //4：獲取到conn fd后注冊到eventpool
        //5：返回conn
		conn, _ := l.Accept()
		// goroutine per conn
		go serve(conn)
	}
}
// 處理一筆到來的 tcp 連接
func serve(conn net.Conn) {
    //關閉conn，從eventpool中移除fd
	defer conn.Close()
	var buf []byte
    //讀取conn中的數(shù)據(jù)，涉及以下事件：
    //1：循環(huán)+非阻塞調用recv(read)
    //2：若未就緒，通過gopark阻塞，等待netpoll輪詢喚醒
	_, _ = conn.Read(buf)
    //向conn中寫入數(shù)據(jù)，涉及以下事件：
    //1：循環(huán)+非阻塞調用writev (write)
    //2：若未就緒，通過gopark阻塞，等待netpoll輪詢喚醒
	_, _ = conn.Write(buf)
}

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系統(tǒng)調用，創(chuàng)建一個socket
	s, err := sysSocket(family, sotype, proto)
    //綁定socket fd
    fd, err = newFD(s, family, sotype, net);
    //...
    //進行了以下事件：
    //1、通過syscall bind指令綁定socket的監(jiān)聽地址
    //2、通過syscall listen指令發(fā)起對socket的監(jiān)聽
    //3、完成epollEvent表的創(chuàng)建（全局執(zhí)行一次）
    //4、將socket fd注冊到epoll事件表中，監(jiān)聽讀寫就緒事件
    err := fd.listenStream(ctx, laddr, listenerBacklog(), ctrlCtxFn);
}

func (fd *netFD) listenStream(ctx context.Context, laddr sockaddr, backlog int, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) error {
	//....
    //通過Bind系統(tǒng)調用綁定監(jiān)聽地址
	if err = syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
		return os.NewSyscallError("bind", err)
	}
    //通過Listen系統(tǒng)調用對socket進行監(jiān)聽
	if err = listenFunc(fd.pfd.Sysfd, backlog); err != nil {
		return os.NewSyscallError("listen", err)
	}
    //fd.init()進行了以下操作：
    //1、完成eventPool的創(chuàng)建
    //2、將socket fd注冊到epoll事件表中
	if err = fd.init(); err != nil {
		return err
	}
	//...
	return nil
}

func (fd *netFD) init() error {
	return fd.pfd.Init(fd.net, true)
}
func (fd *FD) Init(net string, pollable bool) error {
	fd.SysFile.init()
	// We don't actually care about the various network types.
	if net == "file" {
		fd.isFile = true
	}
	if !pollable {
		fd.isBlocking = 1
		return nil
	}
	err := fd.pd.init(fd)
	if err != nil {
		// If we could not initialize the runtime poller,
		// assume we are using blocking mode.
		fd.isBlocking = 1
	}
	return err
}

func (pd *pollDesc) init(fd *FD) error {
    //通過sysOnce結構，完成epoll事件表的唯一一次創(chuàng)建
	serverInit.Do(runtime_pollServerInit)
    //完成init后，進行poll_open
    ctx, errno := runtime_pollOpen(uintptr(fd.Sysfd))
	//...
    //綁定里層的pollDesc實例
    pd.runtimeCtx = ctx
	return nil
}

//go:linkname poll_runtime_pollServerInit internal/poll.runtime_pollServerInit
func poll_runtime_pollServerInit() {
	netpollGenericInit()
}
func netpollGenericInit() {
	if netpollInited.Load() == 0 {
		lockInit(&netpollInitLock, lockRankNetpollInit)
		lock(&netpollInitLock)
		if netpollInited.Load() == 0 {
            //進入netpollinit調用
			netpollinit()
			netpollInited.Store(1)
		}
		unlock(&netpollInitLock)
	}
}

func netpollinit() {
	var errno uintptr
    //進行epollcreate系統(tǒng)調用，創(chuàng)建epoll事件表
	epfd, errno = syscall.EpollCreate1(syscall.EPOLL_CLOEXEC)
	//...
    //創(chuàng)建pipe管道，接收信號，如程序終止：
    //r：信號接收端，會注冊對應的read事件到epoll事件表中
    //w：信號發(fā)送端，有信號到達的時候，會往w發(fā)送信號，并對r產(chǎn)生讀就緒事件
	r, w, errpipe := nonblockingPipe()
	//...
    //在epollEvent中注冊監(jiān)聽r的讀就緒事件
	ev := syscall.EpollEvent{
		Events: syscall.EPOLLIN,
	}
	*(**uintptr)(unsafe.Pointer(&ev.Data)) = &netpollBreakRd
	errno = syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, r, &ev)
	//...
    //使用全局變量緩存pipe的讀寫端
	netpollBreakRd = uintptr(r)
	netpollBreakWr = uintptr(w)
}

//go:linkname poll_runtime_pollOpen internal/poll.runtime_pollOpen
func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
    //獲取一個pollDesc實例
	pd := pollcache.alloc()
	lock(&pd.lock)
	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")
	}
    //綁定socket fd到pollDesc中
	pd.fd = fd
	//...
    //初始化讀寫狀態(tài)標識器為無狀態(tài)
	pd.rg.Store(pdNil)
	pd.wg.Store(pdNil)
	//...
	unlock(&pd.lock)
    //將fd添加進epoll事件表中
	errno := netpollopen(fd, pd)
	//...
    //返回pollDesc實例
	return pd, 0
}

func netpollopen(fd uintptr, pd *pollDesc) uintptr {
	var ev syscall.EpollEvent
    //通過epollctl操作，在EpollEvent中注冊針對fd的監(jiān)聽事件
    //操作類型宏指令：EPOLL_CTL_ADD——添加fd并注冊監(jiān)聽事件
    //事件類型：epollevent.events:
    //1、EPOLLIN:監(jiān)聽讀就緒事件
    //2、EPOLLOUT：監(jiān)聽寫就緒事件
    //3、EPOLLRDHUP：監(jiān)聽中斷事件
    //4、EPOLLET：使用邊緣觸發(fā)模式
	ev.Events = syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP | syscall.EPOLLET
	tp := taggedPointerPack(unsafe.Pointer(pd), pd.fdseq.Load())
	*(*taggedPointer)(unsafe.Pointer(&ev.Data)) = tp
	return syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, int32(fd), &ev)
}

func (fd *netFD) accept()(netfd *netFD, err error){
    // 通過 syscall accept 接收到來的 conn fd
    d, rsa, errcall, err := fd.pfd.Accept()
    // ...
    // 封裝到來的 conn fd
    netfd, err = newFD(d, fd.family, fd.sotype, fd.net)
    // 將 conn fd 注冊到 epoll 事件表中
    err = netfd.init()
    // ...
    return netfd,nil
}

//go:linkname poll_runtime_pollClose internal/poll.runtime_pollClose
func poll_runtime_pollClose(pd *pollDesc) {
	if !pd.closing {
		throw("runtime: close polldesc w/o unblock")
	}
	wg := pd.wg.Load()
	if wg != pdNil && wg != pdReady {
		throw("runtime: blocked write on closing polldesc")
	}
	rg := pd.rg.Load()
	if rg != pdNil && rg != pdReady {
		throw("runtime: blocked read on closing polldesc")
	}
	netpollclose(pd.fd)
	pollcache.free(pd)
}

func netpollclose(fd uintptr) uintptr {
	var ev syscall.EpollEvent
	return syscall.EpollCtl(epfd, syscall.EPOLL_CTL_DEL, int32(fd), &ev)
}

/*
    針對某個 pollDesc 實例，監(jiān)聽指定的mode 就緒事件
        - 返回true——已就緒  返回false——因超時或者關閉導致中斷
        - 其他情況下，會通過 gopark 操作將當前g 阻塞在該方法中
*/
func netpollblock(pd *pollDesc, mode int32, waitio bool) bool {
    //針對mode事件，獲取相應的狀態(tài)
	gpp := &pd.rg
	if mode == 'w' {
		gpp = &pd.wg
	}
	for {
		//關心的io事件就緒，直接返回
		if gpp.CompareAndSwap(pdReady, pdNil) {
			return true
		}
        //關心的io事件未就緒，則置為等待狀態(tài)，G將要被阻塞
		if gpp.CompareAndSwap(pdNil, pdWait) {
			break
		}
		//...
	}
	//...
    //將G置為阻塞態(tài)
		gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceBlockNet, 5)
    //當前g從阻塞態(tài)被喚醒，重置標識器
    old := gpp.Swap(pdNil)
	if old > pdWait {
		throw("runtime: corrupted polldesc")
	}
    //判斷是否是因為所關心的事件觸發(fā)而喚醒
	return old == pdReady
}

// 將 gpp 狀態(tài)標識器的值由 pdWait 修改為當前 g 
func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
	r := atomic.Casuintptr((*uintptr)(gpp), pdWait, uintptr(unsafe.Pointer(gp)))
	if r {
		//增加等待輪詢器的例程計數(shù)。
		//調度器使用它來決定是否阻塞
		//如果沒有其他事情可做，則等待輪詢器。
		netpollAdjustWaiters(1)
	}
	return r
}

// Accept wraps the accept network call.
func (fd *FD) Accept() (int, syscall.Sockaddr, string, error) {
	//...
	for {
        //以非阻塞模式發(fā)起一次accept，嘗試接收conn
		s, rsa, errcall, err := accept(fd.Sysfd)
		if err == nil {
			return s, rsa, "", err
		}
		switch err {
            //忽略中斷類錯誤
		case syscall.EINTR:
			continue
            //尚未有到達的conn
		case syscall.EAGAIN:
            //進入poll_wait流程，監(jiān)聽fd的讀就緒事件，當有conn到達表現(xiàn)為fd可讀。
			if fd.pd.pollable() {
                //假如讀操作未就緒，當前g會被阻塞在方法內部，直到因為超時或者就緒被netpoll ready喚醒。
				if err = fd.pd.waitRead(fd.isFile); err == nil {
					continue
				}
			}
		//...
	}
}

// 指定 mode 為 r 標識等待的是讀就緒事件，然后走入更底層的 poll_wait 流程
func (pd *pollDesc) waitRead(isFile bool) error {
    return pd.wait('r', isFile)
}

func (fd *FD) Read(p []byte) (int, error) {
	//...
	for {
        //非阻塞模式進行一次read調用
		n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)
		if err != nil {
			n = 0
            //進入poll_wait流程，并標識關心讀就緒事件
			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
	}
}

func (fd *FD)Write(p []byte)(int,error){
    // ... 
    for{
    // ...
    // 以非阻塞模式執(zhí)行一次syscall write操作
        n, err := ignoringEINTRIO(syscall.Write, fd.Sysfd, p[nn:max])
        if n >0{
            nn += n
        }
        // 緩沖區(qū)內容都已寫完，直接退出
        if nn ==len(p){
            return nn, err
        }
    // 走入 poll_wait 流程，并標識關心的是該 fd 的寫就緒事件
    if err == syscall.EAGAIN && fd.pd.pollable(){
        // 倘若寫操作未就緒，當前g 會 park 阻塞在該方法內部，直到因超時或者事件就緒而被 netpoll ready 喚醒
        if err = fd.pd.waitWrite(fd.isFile); err ==nil{
            continue
        }
    }
    // ...  
}

//netpoll用于輪詢檢查是否有就緒的io事件
//若發(fā)現(xiàn)了就緒的io事件，檢查是否有pollDesc中的g關心其事件
//若找到了關心其io事件就緒的g，添加到list返回給上游處理
func netpoll(delay int64) (gList, int32) {
	if epfd == -1 {
		return gList{}, 0
	}
	var waitms int32
    //根據(jù)傳入的delay參數(shù)，決定調用epoll_wait的模式：
    //delay < 0:設為阻塞模式（在 gmp 調度流程中，如果某個 p 遲遲獲取不到可執(zhí)行的 g 時，會通過該模式，使得 thread 陷入阻塞態(tài)，但該情況全局最多僅有一例）
    //delay = 0:設為非阻塞模式（通常情況下為此模式，包括 gmp 常規(guī)調度流程、gc 以及全局監(jiān)控線程 sysmon 都是以此模式觸發(fā)的 netpoll 流程）
    //delay > 0:設為超時模式（在 gmp 調度流程中，如果某個 p 遲遲獲取不到可執(zhí)行的 g 時，并且通過 timer 啟動了定時任務時，會令 thread 以超時模式執(zhí)行 epoll_wait 操作）
	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 {
		waitms = 1e9
	}
    //最多接收128個io就緒事件
	var events [128]syscall.EpollEvent
retry:
    //以指定模式調用epoll_wait
	n, errno := syscall.EpollWait(epfd, events[:], int32(len(events)), waitms)
	//...
    //存儲關心io事件就緒的G實例
	var toRun gList
	delta := int32(0)
    //遍歷返回的就緒事件
	for i := int32(0); i < n; i++ {
		ev := events[i]
		if ev.Events == 0 {
			continue
		}
		//pipe接收端的信號處理，檢查是否需要退出netpoll
		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")
			}
		//...
			continue
		}
		var mode int32
        //記錄io就緒事件的類型
		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'
		}
        // 根據(jù) epollevent.data 獲取到監(jiān)聽了該事件的 pollDesc 實例
		if mode != 0 {
			tp := *(*taggedPointer)(unsafe.Pointer(&ev.Data))
			pd := (*pollDesc)(tp.pointer())
			//...
            //檢查是否為G所關心的事件
				delta += netpollready(&toRun, pd, mode)
		}
	}
	return toRun, delta
}

func netpollready(toRun *gList, pd *pollDesc, mode int32) int32 {
	delta := int32(0)
	var rg, wg *g
	if mode == 'r' || mode == 'r'+'w' {
        //就緒事件包含讀就緒，嘗試喚醒pd內部的rg
		rg = netpollunblock(pd, 'r', true, &delta)
	}
	if mode == 'w' || mode == 'r'+'w' {
        //就緒事件包含讀就緒，嘗試喚醒pd內部的wg
		wg = netpollunblock(pd, 'w', true, &delta)
	}
    //存在G實例，則加入list中
	if rg != nil {
		toRun.push(rg)
	}
	if wg != nil {
		toRun.push(wg)
	}
	return delta
}

func netpollunblock(pd *pollDesc, mode int32, ioready bool, delta *int32) *g {
    //獲取存儲的g實例
	gpp := &pd.rg
	if mode == 'w' {
		gpp = &pd.wg
	}
	for {
		old := gpp.Load()
		//...
		new := pdNil
		if ioready {
			new = pdReady
		}
        //將gpp的值從g置換成pdReady
		if gpp.CompareAndSwap(old, new) {
			if old == pdWait {
				old = pdNil
			} else if old != pdNil {
				*delta -= 1
			}
            //返回需要喚醒的g實例
			return (*g)(unsafe.Pointer(old))
		}
	}
}

func findRunnable()(gp *g, inheritTime, tryWakeP bool){
    // ..
    /*
        同時滿足下述三個條件，發(fā)起一次【非阻塞模式】的 netpoll 流程：
            - epoll事件表初始化過
            - 有 g 在等待io 就緒事件
            - 沒有空閑 p 在以【阻塞或超時】模式發(fā)起 netpoll 流程
    */
    if netpollinited()&& atomic.Load(&netpollWaiters)>0&& atomic.Load64(&sched.lastpoll)!=0{
        // 以非阻塞模式發(fā)起一輪 netpoll，如果有 g 需要喚醒，一一喚醒之，并返回首個 g 給上層進行調度
        if list := netpoll(0);!list.empty(){// non-blocking
            // 獲取就緒 g 隊列中的首個 g
            gp := list.pop()
            // 將就緒 g 隊列中其余 g 一一置為就緒態(tài)，并添加到全局隊列
            injectglist(&list)
            // 把首個g 也置為就緒態(tài)
            casgstatus(gp,_Gwaiting,_Grunnable)
            // ...   
            //返回 g 給當前 p進行調度
            return gp,false,false
        }
    }
    // ...
    /*
        同時滿足下述三個條件，發(fā)起一次【阻塞或超時模式】的 netpoll 流程：
            - epoll事件表初始化過
            - 有 g 在等待io 就緒事件
            - 沒有空閑 p 在以【阻塞或超時】模式發(fā)起 netpoll 流程
    */
    if netpollinited()&&(atomic.Load(&netpollWaiters)>0|| pollUntil !=0)&& atomic.Xchg64(&sched.lastpoll,0)!=0{
    // 默認為阻塞模式  
        delay :=int64(-1)
        // 存在定時時間，則設為超時模式
        if pollUntil !=0{
            delay = pollUntil - now
        // ...   
        }
        // 以【阻塞或超時模式】發(fā)起一輪 netpoll
        list := netpoll(delay)// block until new work is available 
    }
    // ...    
}

// The main goroutine.
func main(){
// ...
// 新建一個 m，直接運行 sysmon 函數(shù)
    systemstack(func(){
        newm(sysmon,nil,-1)
    })
    // ...
}
// 全局唯一監(jiān)控線程的執(zhí)行函數(shù)
func sysmon(){
// ...
for{
// ...
/*
        同時滿足下述三個條件，發(fā)起一次【非阻塞模式】的 netpoll 流程：
            - epoll事件表初始化過
            - 沒有空閑 p 在以【阻塞或超時】模式發(fā)起 netpoll 流程
            - 距離上一次發(fā)起 netpoll 流程的時間間隔已超過 10 ms
    */
        lastpoll :=int64(atomic.Load64(&sched.lastpoll))
        if netpollinited()&& lastpoll !=0&& lastpoll+10*1000*1000< now {
            // 以非阻塞模式發(fā)起 netpoll
            list := netpoll(0)// non-blocking - returns list of goroutines
            // 獲取到的  g 置為就緒態(tài)并添加到全局隊列中
            if!list.empty(){
                // ...
                injectglist(&list)
                // ...
            }
        }
    // ...  
    }
}

func pollWork() bool{
    // ...
    // 若全局隊列或 p 的本地隊列非空，則提前返回
    /*
        同時滿足下述三個條件，發(fā)起一次【非阻塞模式】的 netpoll 流程：
            - epoll事件表初始化過
            - 有 g 在等待io 就緒事件
            - 沒有空閑 p 在以【阻塞或超時】模式發(fā)起 netpoll 流程
    */
    if netpollinited()&& atomic.Load(&netpollWaiters)>0&& sched.lastpoll !=0{
    // 所有取得 g 更新為就緒態(tài)并添加到全局隊列
        if list := netpoll(0);!list.empty(){
            injectglist(&list)
            return true
        }
    }
    // ...
}