第二個參數(shù) type 參數(shù)用來指定通信語義，常用enum值有:

除了這幾個，還有兩個enum值在 Go net/http 被用到了，分別是:

第三個參數(shù) protocol 指定通信協(xié)議，對于domain=AF_INET/AF_INET6來說，常見的enum值有 IPPROTO_TCP IPPROTO_UDP，全量。

socket() 返回一個 socket file descriptor，但并沒有協(xié)議和地址與其關(guān)聯(lián)。對于tcp client端而言，可以由系統(tǒng)隨機(jī)指定一個端口；對于一個 tcp server 而言，必須設(shè)置一個公開可訪問的ip地址和端口。bind函數(shù)實現(xiàn)了這個功能:

#include int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);// sockaddr 包含struct sockaddr {  sa_family_t sa_family;  char        sa_data[14];}

其中 sockfd 參數(shù)是 socket函數(shù)的返回值，后面兩個參數(shù)指定協(xié)議類型和地址。

當(dāng)socket被創(chuàng)建以后，它并不能被動地接收創(chuàng)建連接請求，此時它只能作為一個client使用。要被動地接收請求，轉(zhuǎn)化為server，需要依賴 listen函數(shù)。該函數(shù)調(diào)用以后，sockfd的狀態(tài)會從 closed 轉(zhuǎn)換為 listen (netstat 命令可以進(jìn)行查看)。listen函數(shù)的聲明如下:

#include int listen(int sockfd, int backlog);

第一個參數(shù) sockfd 是 socket函數(shù)的返回值，第二個參數(shù)指定了處于ESTABLISHED狀態(tài)的sockets的隊列大小(從Linux 2.2起), 而不是處于 SYNC_RCVD狀態(tài)的sockets隊列的大小。這里提到的兩個狀態(tài)在TCP連接的三次握手中有所定義:

tcp三次握手

backlog 默認(rèn)值是0x80即128，通常可以配置在文件。/proc/sys/net/ipv4/tcp_max_syn_backlog 中，同時受到/proc/sys/net/core/somaxconn 的限制。在 Go 中，這個參數(shù)可以通過func maxListenerBacklog() int獲取。如果隊列滿了，Client端會收到 ECONNREFUSED 錯誤，即 connection refused。

小結(jié)一下，Linux操作系統(tǒng)層面創(chuàng)建一個tcp server，走的邏輯是：

回到 Go net 庫的處理流程，我們關(guān)注的函數(shù)是 sysListener.listenTCP:

// net/tcpsock_posix.go struct sysListenerfunc (sl *sysListener) listenTCP(ctx context.Context, laddr *TCPAddr) (*TCPListener, error) {   fd, err := internetSocket(ctx, sl.network, laddr, nil, syscall.SOCK_STREAM, 0, "listen", sl.ListenConfig.Control)   if err != nil {      return nil, err   }   return &TCPListener{fd: fd, lc: sl.ListenConfig}, nil}

對于一個 tcp server，實例 sl 可以被這樣賦值，系統(tǒng)調(diào)用被封裝在函數(shù) internetSocket 里:

sl := &sysListener{  ListenConfig: *lc,     // lc 是默認(rèn)值  network:      network, // string "tcp"  address:      address, // string "0.0.0.0:8080"}

對于一個 tcp server，函數(shù) internetSocket 接收到的參數(shù)可以是:

func internetSocket(  ctx context.Context,  // context.Background()  net string,           // "tcp"  laddr sockaddr,       // &TCPAddr{IP:"0.0.0.0",Port:8080,Zone:"不知道是啥"}, DNS服務(wù)讀取的地址  raddr sockaddr,       // nil, os=aix|windows|openbsd && mode="dail" 才需要  sotype int,           // syscall.SOCK_STREAM  proto int,            // 0  mode string,          // "listen"  ctrlFn func(string, string, syscall.RawConn) error // sl.ListenConfig.Control) (fd *netFD, err error) {

函數(shù) internetSocket 同樣只是一層封裝，內(nèi)部調(diào)用的是函數(shù) socket。函數(shù)socket內(nèi)部按照順序調(diào)用了socket/bind/listen，返回一個套接字，這個套接字使用network poller，支持異步IO。函數(shù) socket的主要邏輯如下:

// 通過sysSocket執(zhí)行socket系統(tǒng)調(diào)用// 返回一個套接字ss, err := sysSocket(family, sotype, proto)// 封裝int類型的套接字為一個結(jié)構(gòu)體if fd, err = newFD(s, family, sotype, net); err != nil {// ...省略部分代碼// 對于 SOCK_STREAM, SOCK_SEQPACKET類型，調(diào)用bind和listenif laddr != nil && raddr == nil {  switch sotype {  case syscall.SOCK_STREAM, syscall.SOCK_SEQPACKET:    if err := fd.listenStream(laddr, listenerBacklog(), ctrlFn); err != nil {      fd.Close()      return nil, err    }    return fd, nil

對于linux tcp server 而言，函數(shù) sysSocket 的關(guān)鍵只有一行代碼:

s, err := socketFunc(family, sotype|syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC, proto)

SOCK_STREAM、SOCK_NONBLOCK 和 SOCK_CLOEXEC 的語義前面已經(jīng)講過，不再贅述。

socketFunc 定義存放在 net/hook_unix.go 里，與listenFunc在一塊:

// Placeholders for socket system calls.socketFunc        func(int, int, int) (int, error)  = syscall.SocketconnectFunc       func(int, syscall.Sockaddr) error = syscall.ConnectlistenFunc        func(int, int) error              = syscall.ListengetsockoptIntFunc func(int, int, int) (int, error)  = syscall.GetsockoptInt

通過sysSocket拿到套接字以后，通過函數(shù)newFD將其封裝成一個結(jié)構(gòu)體，類型是 *net.netFD:

func newFD(sysfd, family, sotype int, net string) (*netFD, error) {   ret := &netFD{      pfd: poll.FD{         Sysfd:         sysfd,         IsStream:      sotype == syscall.SOCK_STREAM,         ZeroReadIsEOF: sotype != syscall.SOCK_DGRAM && sotype != syscall.SOCK_RAW,      },      family: family,      sotype: sotype,      net:    net,   }   return ret, nil}

其中，結(jié)構(gòu)體內(nèi)部poll.FD定義了讀寫的邏輯，它封裝了6個系統(tǒng)調(diào)用:

readSyscallName     = "read"readFromSyscallName = "recvfrom"readMsgSyscallName  = "recvmsg"writeSyscallName    = "write"writeToSyscallName  = "sendto"writeMsgSyscallName = "sendmsg"

在創(chuàng)建套接字時，已經(jīng)設(shè)置了 SOCK_NONBLOCK flag，如果沒有可用的連接，讀寫數(shù)據(jù)時，會收到 EWOULDBLOCK/EAGAIN 錯誤。Go net庫的處理是等待一段時間，我們看其中一個例子:

// ReadMsgInet4 is ReadMsg, but specialized for syscall.SockaddrInet4.func (fd *FD) ReadMsgInet4(p []byte, oob []byte, flags int, sa4 *syscall.SockaddrInet4) (int, int, int, error) {  if err := fd.readLock(); err != nil {    return 0, 0, 0, err  }  defer fd.readUnlock()  if err := fd.pd.prepareRead(fd.isFile); err != nil {    return 0, 0, 0, err  }  for {    n, oobn, sysflags, err := unix.RecvmsgInet4(fd.Sysfd, p, oob, flags, sa4)    if err != nil {        if err == syscall.EINTR {          continue        }        // TODO(dfc) should n and oobn be set to 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, oobn, sysflags, err  }}

回到 func (sl *sysListener) listenTCP 方法，函數(shù) internetSocket 返回一個套接字結(jié)構(gòu)體的實例，用來構(gòu)建 TCPListener 對象&TCPListener{fd: fd, lc: sl.ListenConfig}。后面 accept tcp conn 時，會用到 net.netFD 的 accept 方法，后者只是封裝了 poll.DF 的 Accept 方法。

回到 net/http 下的 struct Server 的 ListenAndServe 方法，它包含兩步:

前面詳細(xì)說明了第一步的細(xì)節(jié)，后面我們看第二步如何Serve。

對于 linux下的 tcp server，系統(tǒng)調(diào)用 accept 發(fā)生在 socket、bind、listen 之后，它從內(nèi)核中的 ESTABLISHED 隊列中獲取一個建立完成的鏈接。通過函數(shù)socket生成的套接字sockfd可以是阻塞或非阻塞(NONBLOCK)，它的函數(shù)聲明如下:

#include int accept(int sockfd, struct sockaddr *restrict addr,          socklen_t *restrict addrlen);#define _GNU_SOURCE             /* See feature_test_macros(7) */#include int accept4(int sockfd, struct sockaddr *restrict addr,          socklen_t *restrict addrlen, int flags);

對于阻塞/非阻塞的套接字, accept 的表現(xiàn)并不相同:

Go net庫使用的是非阻塞的套接字，我們看這部分代碼的邏輯:

// net/net.go struct Serverfunc (srv *Server) Serve(l net.Listener) error {  for {    rw, err := l.Accept()    // ... 省略部分代碼

這里 ln 的類型是 *TCPListener, 其方法Accept的定義如下:

// Accept implements the Accept method in the Listener interface; it// waits for the next call and returns a generic Conn.func (l *TCPListener) Accept() (Conn, error) {  if !l.ok() {    return nil, syscall.EINVAL  }  c, err := l.accept()  if err != nil {    return nil, &OpError{Op: "accept", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err}  }  return c, nil}func (ln *TCPListener) accept() (*TCPConn, error) {  fd, err := ln.fd.accept()  if err != nil {    return nil, err  }  tc := newTCPConn(fd)  if ln.lc.KeepAlive >= 0 {    setKeepAlive(fd, true)    ka := ln.lc.KeepAlive    if ln.lc.KeepAlive == 0 {      ka = defaultTCPKeepAlive    }    setKeepAlivePeriod(fd, ka)  }  return tc, nil}

struct TCPListener 的結(jié)構(gòu)如下, accept 依賴成員變量 fd *net.netFD，它通過 pdf poll.FD 的 Accept 方法獲取client端的套接字，并封裝成一個 net.netFD 對象:

// TCPListener is a TCP network listener. Clients should typically// use variables of type Listener instead of assuming TCP.type TCPListener struct {  fd *netFD  lc ListenConfig}func (fd *netFD) accept() (netfd *netFD, err error) {  d, rsa, errcall, err := fd.pfd.Accept()  // ... 省略部分代碼  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  }  lsa, _ := syscall.Getsockname(netfd.pfd.Sysfd)  netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))  return netfd, nil}

繼續(xù)看 poll.FD 的方法 Accept。它內(nèi)部是一個 for 循環(huán)，先嘗試通過系統(tǒng)調(diào)用accpt4 獲取一個套接字，結(jié)果會有下面幾種情況:

// Accept wraps the accept network call.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  }}// 代碼路徑: internal/poll/sock_cloexec.go// Wrapper around the accept system call that marks the returned file// descriptor as nonblocking and close-on-exec.func accept(s int) (int, syscall.Sockaddr, string, error) {  ns, sa, err := Accept4Func(s, syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC)  // ... 省略部分代碼

另外可以看到，accept4 系統(tǒng)調(diào)用時，傳入了 SOCK_NONBLOCK 和 SOCK_CLOEXEC 兩個 flag，socket 系統(tǒng)調(diào)用也使用了這兩個 flag。

通過 ln.Accept 獲取到ESTABLISHED連接的套接字以后，就可以對遠(yuǎn)端的client進(jìn)行服務(wù)了。

在本文中，總共有兩類套接字(socket):

在??第一篇??文章"Go BIO/NIO探討(1)：Gin框架中如何處理HTTP請求"中，我們提到了兩層 for 循環(huán)，本文只是講了第一層。從阻塞、非阻塞的角度來看，TCPListener.Accept方法看起來是block的實現(xiàn)，但底層的套接字和系統(tǒng)調(diào)用設(shè)置了 NONBLOCK flag，可以說是基于 NONBLOCK 的方式實現(xiàn)的。單純從網(wǎng)絡(luò)的視角看，這稱得上是 Non-blocking IO 了。

關(guān)鍵詞：