int listenfd = socket(AF_INET, SOCK_STREAM, 0);

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 綁定到所有可用接口
server_addr.sin_port = htons(8080); // 綁定到 8080 端口
bind(listenfd, (struct sockaddr *)&server_addr, sizeof(server_addr));

listen(listenfd, 5); // 允許 5 個(gè)待處理的連接

// 阻塞等待
struct sockaddr_in client_addr;
socklen_t client_addr_len = sizeof(client_addr);
int connectfd = accept(listenfd, (struct sockaddr *)&client_addr, &client_addr_len);

// 啟動(dòng) tcp server 代碼示例
func main() {
	/*
		- 創(chuàng)建 tcp 端口監(jiān)聽器
		    - 創(chuàng)建 socket fd，bind、accept
			- 創(chuàng)建 epoll 事件表（epoll_create）
			- socket fd 注冊(cè)到 epoll 事件表（epoll_ctl：add）

	*/
	l, _ := net.Listen("tcp", ":8080")
	// eventloop reactor 模型
	for {
		/*
			- 等待 tcp 連接到達(dá)
			    - loop + 非阻塞模式調(diào)用 accept
				- 若未就緒，則通過 gopark 進(jìn)行阻塞
				- 等待 netpoller 輪詢喚醒
				     - 檢查是否有 io 事件就緒（epoll_wait——nonblock）
					 - 若發(fā)現(xiàn)事件就緒 通過 goready 喚醒 g
				- accept 獲取 conn fd 后注冊(cè)到 epoll 事件表（epoll_ctl：add）
				- 返回 conn
		*/
		conn, _ := l.Accept()
		// goroutine per conn
		go serve(conn)
	}
}

// 處理一筆到來的 tcp 連接
func serve(conn net.Conn) {
	/*
		- 關(guān)閉 conn
		   - 從 epoll 事件表中移除該 fd（epoll_ctl：remove）
		   - 銷毀該 fd
	*/
	defer conn.Close()
	var buf []byte
	/*
		- 讀取連接中的數(shù)據(jù)
		   - loop + 非阻塞模式調(diào)用 recv (read)
		   - 若未就緒，則通過 gopark 進(jìn)行阻塞
		   - 等待 netpoller 輪詢喚醒
			    - 檢查是否有 io 事件就緒（epoll_wait——nonblock）
				- 若發(fā)現(xiàn)事件就緒 通過 goready 喚醒 g
	*/
	_, _ = conn.Read(buf)
	/*
		- 向連接中寫入數(shù)據(jù)
		   - loop + 非阻塞模式調(diào)用 writev (write)
		   - 若未就緒，則通過 gopark 進(jìn)行阻塞
		   - 等待 netpoller 輪詢喚醒
			    - 檢查是否有 io 事件就緒（epoll_wait：nonblock）
				- 若發(fā)現(xiàn)事件就緒 通過 goready 喚醒 g
	*/
	_, _ = conn.Write(buf)
}

 // 在 epoll 事件表中注冊(cè)監(jiān)聽 r 的讀就緒事件
	ev := epollevent{
		events: _EPOLLIN,
	}

// Accept wraps the accept network call.
func (fd *FD) Accept() (int, syscall.Sockaddr, string, error) {
        // ...
        for {
                // 以nonblock 模式發(fā)起一次 syscall accept 嘗試接收到來的 conn
		s, rsa, errcall, err := accept(fd.Sysfd)
                // 接收conn成功，直接返回結(jié)果
                if err == nil {
			return s, rsa, "", err
		}
		switch err {
                // 中斷類錯(cuò)誤直接忽略
		case syscall.EINTR:
			continue
                // 當(dāng)前未有到達(dá)的conn 
		case syscall.EAGAIN:
       // 走入 poll_wait 流程，并標(biāo)識(shí)關(guān)心的是 socket fd 的讀就緒事件
       // (當(dāng)conn 到達(dá)時(shí)，表現(xiàn)為 socket fd 可讀)
			if fd.pd.pollable() {
         // 倘若讀操作未就緒，當(dāng)前g 會(huì) park 阻塞在該方法內(nèi)部，直到因超時(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)
}

// Read implements io.Reader.
func (fd *FD) Read(p []byte) (int, error) {
        // ... 
	for {
                // 以非阻塞模式執(zhí)行一次syscall read 操作 
		n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)
		if err != nil {
			n = 0
                        // 走入 poll_wait 流程，并標(biāo)識(shí)關(guān)心的是該 fd 的讀就緒事件
			if err == syscall.EAGAIN && fd.pd.pollable() {
                                // 倘若讀操作未就緒，當(dāng)前g 會(huì) park 阻塞在該方法內(nèi)部，直到因超時(shí)或者事件就緒而被 netpoll ready 喚醒
				if err = fd.pd.waitRead(fd.isFile); err == nil {
					continue
				}
			}
		}
		err = fd.eofError(n, err)
		return n, err
	}
}

// gmp 核心調(diào)度流程：g0 為當(dāng)前 p 找到下一個(gè)調(diào)度的  g
    /*
        pick g 的核心邏輯：
             1）每調(diào)度 61 次，需要專門嘗試處理一次全局隊(duì)列（防止饑餓）
             2）嘗試從本地隊(duì)列中獲取 g
             3）嘗試從全局隊(duì)列中獲取 g
             4）以【非阻塞模式】調(diào)度 netpoll 流程，獲取所有需要喚醒的 g 進(jìn)行喚醒，并獲取其中的首個(gè)g
             5）從其他 p 中竊取一半的 g 填充到本地隊(duì)列
             6）仍找不到合適的 g，則協(xié)助 gc 
             7）以【阻塞或者超時(shí)】模式，調(diào)度netpoll 流程（全局僅有一個(gè) p 能走入此分支）
             8）當(dāng)前m 添加到全局隊(duì)列的空閑隊(duì)列中，停止當(dāng)前 m
    */

func findRunnable() (gp *g, inheritTime, tryWakeP bool) {
    // ..
    /*
      同時(shí)滿足下述三個(gè)條件，發(fā)起一次【非阻塞模式】的 netpoll 流程：
        - epoll事件表初始化過
        - 有 g 在等待io 就緒事件
        - 沒有空閑 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í)滿足下述三個(gè)條件，發(fā)起一次【阻塞或超時(shí)模式】的 netpoll 流程：
            - epoll事件表初始化過
            - 有 g 在等待io 就緒事件
            - 沒有空閑 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)控線程的執(zhí)行函數(shù)
func sysmon() {
        // ...
	for {
              // ...
        /*
        同時(shí)滿足下述三個(gè)條件，發(fā)起一次【非阻塞模式】的 netpoll 流程：
            - epoll事件表初始化過
            - 沒有空閑 p 在以【阻塞或超時(shí)】模式發(fā)起 netpoll 流程
            - 距離上一次發(fā)起 netpoll 流程的時(shí)間間隔已超過 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 startTheWorldWithSema(emitTraceEvent bool) int64 {
        // 斷言世界已停止
	assertWorldStopped()
        // ...
        // 如果 epoll 事件表初始化過，則以非阻塞模式執(zhí)行一次 netpoll
	if netpollinited() {
                // 所有取得的 g 置為就緒態(tài)并添加到全局隊(duì)列
		list := netpoll(0) // non-blocking
		injectglist(&list)
	}
        // ...
}

// netpoll checks for ready network connections.
// Returns list of goroutines that become runnable.
/*
    - netpoll 流程用于輪詢檢查是否有就緒的 io 事件
    - 如果有就緒 io 事件，還需要檢查是否有 pollDesc 中的 g 關(guān)心該事件
    - 找到所有關(guān)心該就緒 io 事件的 g，添加到 list 中返回給上游進(jìn)行 goready 喚醒
*/
func netpoll(delay int64) gList {
     /*
        根據(jù)傳入的 delay 參數(shù)，決定調(diào)用 epoll_wait 的模式
            - delay < 0：設(shè)為 -1 阻塞模式（在 gmp 調(diào)度流程中，如果某個(gè) p 遲遲獲取不到可執(zhí)行的 g 時(shí)，會(huì)通過該模式，使得 thread 陷入阻塞態(tài)，但該情況全局最多僅有一例）
            - delay = 0：設(shè)為 0 非阻塞模式（通常情況下為此模式，包括 gmp 常規(guī)調(diào)度流程、gc 以及全局監(jiān)控線程 sysmon 都是以此模式觸發(fā)的 netpoll 流程）
            - delay > 0：設(shè)為超時(shí)模式（在 gmp 調(diào)度流程中，如果某個(gè) p 遲遲獲取不到可執(zhí)行的 g 時(shí)，并且通過 timer 啟動(dòng)了定時(shí)任務(wù)時(shí)，會(huì)令 thread 以超時(shí)模式執(zhí)行 epoll_wait 操作）
    */
     var waitms int32
     if delay < 0 {
		waitms = -1
     } else if delay == 0 {
		waitms = 0
     // 針對(duì) delay 時(shí)長(zhǎng)取整
     } else if delay < 1e6 {
		waitms = 1
     } else if delay < 1e15 {
		waitms = int32(delay / 1e6)
     } else {
     // 1e9 ms == ~11.5 days.
		waitms = 1e9
     }
     // 一次最多接收 128 個(gè) io 就緒事件	
     var events [128]epollevent
retry:
     // 以指定模式，調(diào)用 epoll_wait 指令
	n := epollwait(epfd, &events[0], int32(len(events)), waitms)
     // ...
 
     // 遍歷就緒的每個(gè) io 事件	
     var toRun gList
     for i := int32(0); i < n; i++ {
	   ev := &events[i]
           if ev.events == 0 {
                continue
           }

           // pipe 接收端的信號(hào)量處理
           if *(**uintptr)(unsafe.Pointer(&ev.data)) == &netpollBreakRd {
           // ...
            }
 
            /*
             根據(jù) io 事件類型，標(biāo)識(shí)出 mode：
                 - EPOLL_IN -> r；
                 - EPOLL_OUT -> w;
                 - 錯(cuò)誤或者中斷事件 -> r & w;
             */
            var mode int32
            if ev.events&(_EPOLLIN|_EPOLLRDHUP|_EPOLLHUP|_EPOLLERR) != 0 {
			mode += 'r'
            }
            if ev.events&(_EPOLLOUT|_EPOLLHUP|_EPOLLERR) != 0 {
			mode += 'w'
            }
            // 根據(jù) epollevent.data 獲取到監(jiān)聽了該事件的 pollDesc 實(shí)例
            if mode != 0 {
			pd := *(**pollDesc)(unsafe.Pointer(&ev.data))
                        // ...			
                        // 嘗試針對(duì)對(duì)應(yīng) pollDesc 進(jìn)行喚醒操作
                        netpollready(&toRun, pd, mode)
            }
      }
      return toRun
}




/*
    epollwait 操作：
        - epfd：epoll 事件表 fd 句柄
        - ev：用于承載就緒 epoll event 的容器
        - nev：ev 的容量
        - timeout：
            - -1：阻塞模式
            - 0：非阻塞模式：
            - >0：超時(shí)模式. 單位 ms
        - 返回值 int32：就緒的 event 數(shù)量
*/
func epollwait(epfd int32, ev *epollevent, nev, timeout int32) int32





// It declares that the fd associated with pd is ready for I/O.
// The toRun argument is used to build a list of goroutines to return
// from netpoll. The mode argument is 'r', 'w', or 'r'+'w' to indicate
/*
 根據(jù) pd 以及 mode 標(biāo)識(shí)的 io 就緒事件，獲取需要進(jìn)行 ready 喚醒的 g list
 對(duì)應(yīng) g 會(huì)存儲(chǔ)到 toRun 這個(gè) list 容器當(dāng)中
*/
func netpollready(toRun *gList, pd *pollDesc, mode int32) {
	var rg, wg *g
	if mode == 'r' || mode == 'r'+'w' {
        // 倘若到達(dá)事件包含讀就緒，嘗試獲取需要 ready 喚醒的 g
		rg = netpollunblock(pd, 'r', true)
	}
	if mode == 'w' || mode == 'r'+'w' {
 // 倘若到達(dá)事件包含寫就緒，嘗試獲取需要 ready 喚醒的 g
		wg = netpollunblock(pd, 'w', true)
	}
 // 找到需要喚醒的 g，添加到 glist 中返回給上層
	if rg != nil {
		toRun.push(rg)
	}
	if wg != nil {
		toRun.push(wg)
	}
}




/*
 根據(jù)指定的就緒io 事件類型以及 pollDesc，判斷是否有 g 需要被喚醒. 若返回結(jié)果非空，則為需要喚醒的 g
*/
func netpollunblock(pd *pollDesc, mode int32, ioready bool) *g {
        // 根據(jù) io 事件類型，獲取 pollDesc 中對(duì)應(yīng)的狀態(tài)標(biāo)識(shí)器
        gpp := &pd.rg
	if mode == 'w' {
		gpp = &pd.wg
	}

	for {
                // 從 gpp 中取出值，此時(shí)該值應(yīng)該為調(diào)用過 park 操作的 g
		old := gpp.Load()
                 // ... 
		if ioready {
			new = pdReady
		}
                // 通過 cas 操作，將 gpp 值由 g 置換成 pdReady
		if gpp.CompareAndSwap(old, new) {
                        // 返回需要喚醒的 g 
			return (*g)(unsafe.Pointer(old))
		}
	}
}