type pollDesc struct {
	runtimeCtx uintptr
}

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

type pollCache struct {
	lock  mutex
	first *pollDesc
}

//從pollCache中分配得到一個(gè)pollDesc實(shí)例
func (c *pollCache) alloc() *pollDesc {
	lock(&c.lock)
    //如果鏈表為空，則進(jìn)行初始化
	if c.first == nil {
        //pdSize = 248
		const pdSize = unsafe.Sizeof(pollDesc{})
        //4096 / 248 = 16
		n := pollBlockSize / pdSize
		if n == 0 {
			n = 1
		}
        //分配指定大小的內(nèi)存空間
		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用于將一個(gè)pollDesc放回pollCache
func (c *pollCache) free(pd *pollDesc) {
	//...
	lock(&c.lock)
	pd.link = c.first
	c.first = pd
	unlock(&c.lock)
}

// 啟動(dòng) tcp server 代碼示例
func main() {
    //創(chuàng)建TCP端口監(jiān)聽(tīng)器，涉及以下事件：
    //1：創(chuàng)建socket fd，調(diào)用bind和accept系統(tǒng)接口函數(shù)
    //2：調(diào)用epoll_create，創(chuàng)建eventpool
    //3：調(diào)用epoll_ctl(ADD)，將socket fd注冊(cè)到epoll事件表
	l, _ := net.Listen("tcp", ":8080")
	// eventloop reactor 模型
	for {
        //等待TCP連接到達(dá)，涉及以下事件：
        //1：循環(huán)+非阻塞調(diào)用accept
        //2：若未就緒，則調(diào)用gopark進(jìn)行阻塞
        //3：等待netpoller輪詢(xún)喚醒
        //4：獲取到conn fd后注冊(cè)到eventpool
        //5：返回conn
		conn, _ := l.Accept()
		// goroutine per conn
		go serve(conn)
	}
}
// 處理一筆到來(lái)的 tcp 連接
func serve(conn net.Conn) {
    //關(guān)閉conn，從eventpool中移除fd
	defer conn.Close()
	var buf []byte
    //讀取conn中的數(shù)據(jù)，涉及以下事件：
    //1：循環(huán)+非阻塞調(diào)用recv(read)
    //2：若未就緒，通過(guò)gopark阻塞，等待netpoll輪詢(xún)喚醒
	_, _ = conn.Read(buf)
    //向conn中寫(xiě)入數(shù)據(jù)，涉及以下事件：
    //1：循環(huán)+非阻塞調(diào)用writev (write)
    //2：若未就緒，通過(guò)gopark阻塞，等待netpoll輪詢(xún)喚醒
	_, _ = 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) {
    //進(jìn)行socket系統(tǒng)調(diào)用，創(chuàng)建一個(gè)socket
	s, err := sysSocket(family, sotype, proto)
    //綁定socket fd
    fd, err = newFD(s, family, sotype, net);
    //...
    //進(jìn)行了以下事件：
    //1、通過(guò)syscall bind指令綁定socket的監(jiān)聽(tīng)地址
    //2、通過(guò)syscall listen指令發(fā)起對(duì)socket的監(jiān)聽(tīng)
    //3、完成epollEvent表的創(chuàng)建（全局執(zhí)行一次）
    //4、將socket fd注冊(cè)到epoll事件表中，監(jiān)聽(tīng)讀寫(xiě)就緒事件
    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 {
	//....
    //通過(guò)Bind系統(tǒng)調(diào)用綁定監(jiān)聽(tīng)地址
	if err = syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
		return os.NewSyscallError("bind", err)
	}
    //通過(guò)Listen系統(tǒng)調(diào)用對(duì)socket進(jìn)行監(jiān)聽(tīng)
	if err = listenFunc(fd.pfd.Sysfd, backlog); err != nil {
		return os.NewSyscallError("listen", err)
	}
    //fd.init()進(jìn)行了以下操作：
    //1、完成eventPool的創(chuàng)建
    //2、將socket fd注冊(cè)到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 {
    //通過(guò)sysOnce結(jié)構(gòu)，完成epoll事件表的唯一一次創(chuàng)建
	serverInit.Do(runtime_pollServerInit)
    //完成init后，進(jìn)行poll_open
    ctx, errno := runtime_pollOpen(uintptr(fd.Sysfd))
	//...
    //綁定里層的pollDesc實(shí)例
    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 {
            //進(jìn)入netpollinit調(diào)用
			netpollinit()
			netpollInited.Store(1)
		}
		unlock(&netpollInitLock)
	}
}

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

//go:linkname poll_runtime_pollOpen internal/poll.runtime_pollOpen
func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
    //獲取一個(gè)pollDesc實(shí)例
	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
	//...
    //初始化讀寫(xiě)狀態(tài)標(biāo)識(shí)器為無(wú)狀態(tài)
	pd.rg.Store(pdNil)
	pd.wg.Store(pdNil)
	//...
	unlock(&pd.lock)
    //將fd添加進(jìn)epoll事件表中
	errno := netpollopen(fd, pd)
	//...
    //返回pollDesc實(shí)例
	return pd, 0
}

func netpollopen(fd uintptr, pd *pollDesc) uintptr {
	var ev syscall.EpollEvent
    //通過(guò)epollctl操作，在EpollEvent中注冊(cè)針對(duì)fd的監(jiān)聽(tīng)事件
    //操作類(lèi)型宏指令：EPOLL_CTL_ADD——添加fd并注冊(cè)監(jiān)聽(tīng)事件
    //事件類(lèi)型：epollevent.events:
    //1、EPOLLIN:監(jiān)聽(tīng)讀就緒事件
    //2、EPOLLOUT：監(jiān)聽(tīng)寫(xiě)就緒事件
    //3、EPOLLRDHUP：監(jiān)聽(tīng)中斷事件
    //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){
    // 通過(guò) syscall accept 接收到來(lái)的 conn fd
    d, rsa, errcall, err := fd.pfd.Accept()
    // ...
    // 封裝到來(lái)的 conn fd
    netfd, err = newFD(d, fd.family, fd.sotype, fd.net)
    // 將 conn fd 注冊(cè)到 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)
}

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

// 將 gpp 狀態(tài)標(biāo)識(shí)器的值由 pdWait 修改為當(dāng)前 g 
func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
	r := atomic.Casuintptr((*uintptr)(gpp), pdWait, uintptr(unsafe.Pointer(gp)))
	if r {
		//增加等待輪詢(xún)器的例程計(jì)數(shù)。
		//調(diào)度器使用它來(lái)決定是否阻塞
		//如果沒(méi)有其他事情可做，則等待輪詢(xún)器。
		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 {
            //忽略中斷類(lèi)錯(cuò)誤
		case syscall.EINTR:
			continue
            //尚未有到達(dá)的conn
		case syscall.EAGAIN:
            //進(jìn)入poll_wait流程，監(jiān)聽(tīng)fd的讀就緒事件，當(dāng)有conn到達(dá)表現(xiàn)為fd可讀。
			if fd.pd.pollable() {
                //假如讀操作未就緒，當(dāng)前g會(huì)被阻塞在方法內(nèi)部，直到因?yàn)槌瑫r(shí)或者就緒被netpoll ready喚醒。
				if err = fd.pd.waitRead(fd.isFile); err == nil {
					continue
				}
			}
		//...
	}
}

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

func (fd *FD) Read(p []byte) (int, error) {
	//...
	for {
        //非阻塞模式進(jìn)行一次read調(diào)用
		n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)
		if err != nil {
			n = 0
            //進(jìn)入poll_wait流程，并標(biāo)識(shí)關(guān)心讀就緒事件
			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ū)內(nèi)容都已寫(xiě)完，直接退出
        if nn ==len(p){
            return nn, err
        }
    // 走入 poll_wait 流程，并標(biāo)識(shí)關(guān)心的是該 fd 的寫(xiě)就緒事件
    if err == syscall.EAGAIN && fd.pd.pollable(){
        // 倘若寫(xiě)操作未就緒，當(dāng)前g 會(huì) park 阻塞在該方法內(nèi)部，直到因超時(shí)或者事件就緒而被 netpoll ready 喚醒
        if err = fd.pd.waitWrite(fd.isFile); err ==nil{
            continue
        }
    }
    // ...  
}

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

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

// The main goroutine.
func main(){
// ...
// 新建一個(gè) m，直接運(yùn)行 sysmon 函數(shù)
    systemstack(func(){
        newm(sysmon,nil,-1)
    })
    // ...
}
// 全局唯一監(jiān)控線(xiàn)程的執(zhí)行函數(shù)
func sysmon(){
// ...
for{
// ...
/*
        同時(shí)滿(mǎn)足下述三個(gè)條件，發(fā)起一次【非阻塞模式】的 netpoll 流程：
            - epoll事件表初始化過(guò)
            - 沒(méi)有空閑 p 在以【阻塞或超時(shí)】模式發(fā)起 netpoll 流程
            - 距離上一次發(fā)起 netpoll 流程的時(shí)間間隔已超過(guò) 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)并添加到全局隊(duì)列中
            if!list.empty(){
                // ...
                injectglist(&list)
                // ...
            }
        }
    // ...  
    }
}

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