深入理解 Golang: 网络编程

已于 2023-07-02 19:19:24 修改
阅读量1k 收藏
点赞数 2
分类专栏： Golang 文章标签： 网络 golang tcp/ip
于 2023-07-02 19:05:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/by6671715/article/details/131500929
版权

Go 中的 Epoll

关于计算机网络分层与 TCP 通信过程过程此处不再赘述。

  • 考虑到 TCP 通信过程中各种复杂操作，包括三次握手，四次挥手等，多数操作系统都提供了 Socket 作为 TCP 网络连接的抽象。
  • Linux -> Internet domain socket -> SOCK_STREAM
  • Linux 中 Socket 以 “文件描述符” FD 作为标识

在进行 Socket 通信时，服务端同时操作多个 Socket，此时便需要 IO 模型操作方案。：

  • 阻塞 IO。传统 C/C++ 方案，同步读写 Socket（一个线程一个 Socket），线程陷入内核态，当读写成功后，切换回用户态继续执行。
  • 非阻塞 IO。应用会不断自旋轮询，直到 Socket 可以读写，如果暂时无法收发数据，会返回错误。
  • Epoll 多路复用。提供了事件列表，不需要查询各个 Socket。其注册多个 Socket 事件，调用 epoll ，当有事件发生则返回。

Epoll 是 Linux 下的 event poll，Windows 中为 IOCP, Mac 中为 kqueue。

在 Go 中，内部采用结合阻塞模型和多路复用的方法。在这里就不再是线程操作 Socket，而是 Goroutine 协程。每个协程关心一个 Socket 连接：

  • 在底层使用操作系统的多路复用 IO。
  • 在协程层次使用阻塞模型。
  • 阻塞协程时，休眠协程。

我们知道，Go 是一个跨平台的语言，不同平台/操作系统下提供的 Epoll 实现不同，所以 Go 在 Epoll/IOCP/kqueue 上再独立了一层 epoll 抽象层，用于屏蔽各个系统的差异性，抽象各系统对多路复用器的实现。
在这里插入图片描述

Go Network Poller 多路复用器的抽象，以 Linux 为例：

  • Go Network Poller 对于多路复用器的抽象和适配
  • epoll_create() -> netpollinit()
  • epoll_ctl() -> netpollopen()
  • epoll_wait() -> netpoll()
// Integrated network poller (platform-independent part).
// A particular implementation (epoll/kqueue/port/AIX/Windows)
// must define the following functions:
//
// func netpollinit()
//     Initialize the poller. Only called once.
//
// func netpollopen(fd uintptr, pd *pollDesc) int32
//     Arm edge-triggered notifications for fd. The pd argument is to pass
//     back to netpollready when fd is ready. Return an errno value.
//
// func netpollclose(fd uintptr) int32
//     Disable notifications for fd. Return an errno value.
//
// func netpoll(delta int64) gList
//     Poll the network. If delta < 0, block indefinitely. If delta == 0,
//     poll without blocking. If delta > 0, block for up to delta nanoseconds.
//     Return a list of goroutines built by calling netpollready.
//
// func netpollBreak()
//     Wake up the network poller, assumed to be blocked in netpoll.
//
// func netpollIsPollDescriptor(fd uintptr) bool
//     Reports whether fd is a file descriptor used by the poller.

上诉所有方法的实现都在 %GOROOT/src/runtime/netpoll_epoll.go%

netpollinit() 新建多路复用器

  1. 新建 Epoll，不同系统对应不同的实现方式。
  2. 新建一个 Pipe 管道用于中断 Epoll。
  3. 将 “管道有数据到达” 事件注册到 Epoll 中。
func netpollinit() {
    var errno uintptr

    // 1. 新建 Epoll，不同系统对应不同的实现方式
    epfd, errno = syscall.EpollCreate1(syscall.EPOLL_CLOEXEC)
    if errno != 0 {
        println("runtime: epollcreate failed with", errno)
        throw("runtime: netpollinit failed")
    }

    // 用来中断 Epoll 的管道
    r, w, errpipe := nonblockingPipe()
    if errpipe != 0 {
        println("runtime: pipe failed with", -errpipe)
        throw("runtime: pipe failed")
    }

    // 3. 注册事件
    ev := syscall.EpollEvent{
        Events: syscall.EPOLLIN,
    }
    *(**uintptr)(unsafe.Pointer(&ev.Data)) = &netpollBreakRd
    errno = syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, r, &ev)
    if errno != 0 {
        println("runtime: epollctl failed with", errno)
        throw("runtime: epollctl failed")
    }
    netpollBreakRd = uintptr(r)
    netpollBreakWr = uintptr(w)
}

netpollopen() 插入事件

  1. 传入一个 Socket 的 FD 和 pollDesc 指针。
  2. pollDesc 指针是 Socket 相关详细信息。
  3. pollDesc 指针中记录了哪个协程在休眠等待此 Socket。
  4. 将 Socket 的可读/可写/断开事件注册到 Epoll 中。
func netpollopen(fd uintptr, pd *pollDesc) uintptr {
    var ev syscall.EpollEvent

    // 事件类型
    ev.Events = syscall.EPOLLIN | syscall.EPOLLOUT | syscall.EPOLLRDHUP | syscall.EPOLLET
    *(**pollDesc)(unsafe.Pointer(&ev.Data)) = pd
    return syscall.EpollCtl(epfd, syscall.EPOLL_CTL_ADD, int32(fd), &ev)
}

netpoll() 查询事件

  1. 调用 EpollWait() 方法，查询有哪些事件发生
  2. 根据 Socket 相关的 pollDesc 信息，返回哪些协程可以唤醒。
func netpoll(delay int64) gList {
    // 1. 查询哪些事件发生
    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{}
        }
        goto retry
    }
    // 2. 根据 Socket 相关的 pollDesc 信息，返回哪些协程可以唤醒。
    var toRun gList
    for i := int32(0); i < n; i++ {
        ev := events[i]
        if ev.Events == 0 {
            continue
        }

        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")
            }
            if delay != 0 {
                var tmp [16]byte
                read(int32(netpollBreakRd), noescape(unsafe.Pointer(&tmp[0])), int32(len(tmp)))
                netpollWakeSig.Store(0)
            }
            continue
        }

        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 {
            pd := *(**pollDesc)(unsafe.Pointer(&ev.Data))
            pd.setEventErr(ev.Events == syscall.EPOLLERR)
            netpollready(&toRun, pd, mode)
        }
    }

    // 协程列表
    return toRun
}

Go Network Poller

Network Poller 初始化

  • 初始化一个 Network Poller。
  • 调用 netpollinit() 新建多路复用器。
// %GOROOT%src/runtime/netpoll.go
func poll_runtime_pollServerInit() {
    netpollGenericInit()
}

func netpollGenericInit() {
    // 每个 Go 应用只初始化一次
    if netpollInited.Load() == 0 {
        lockInit(&netpollInitLock, lockRankNetpollInit)
        lock(&netpollInitLock)
        if netpollInited.Load() == 0 {
            // 新建多路复用器
            netpollinit()
            netpollInited.Store(1)
        }
        unlock(&netpollInitLock)
    }
}

关于 pollDesc，是 runtime 包对 Socket 的详细描述：

type pollDesc struct {
    _    sys.NotInHeap
    link *pollDesc // in pollcache, protected by pollcache.lock
    fd   uintptr   // constant for pollDesc usage lifetime
    atomicInfo atomic.Uint32 // atomic pollInfo


    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
    user    uint32    // user settable cookie
    rseq    uintptr   // protects from stale read timers
    rt      timer     // read deadline timer (set if rt.f != nil)
    rd      int64     // read deadline (a nanotime in the future, -1 when expired)
    wseq    uintptr   // protects from stale write timers
    wt      timer     // write deadline timer
    wd      int64     // write deadline (a nanotime in the future, -1 when expired)
    self    *pollDesc // storage for indirect interface. See (*pollDesc).makeArg.
}

Network Poller 新增监听 Socket

  • 在 pollCache 链表中分配一个 pollDesc。
  • 初始化 pollDesc，rg，wg 都为 0。
  • 调用 netpollopen() 插入事件
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")
    }

    // 初始化 pollDesc
    pd.fd = fd
    pd.closing = false
    pd.setEventErr(false)
    pd.rseq++
    pd.rg.Store(pdNil)
    pd.rd = 0
    pd.wseq++
    pd.wg.Store(pdNil)
    pd.wd = 0
    pd.self = pd
    pd.publishInfo()
    unlock(&pd.lock)

    // 插入事件
    errno := netpollopen(fd, pd)
    if errno != 0 {
        pollcache.free(pd)
        return nil, int(errno)
    }
    return pd, 0
}

Network Poller 收发数据

  • Socket 已经可读写时
    • runtime 的 g0 协程循环调用 netpoll() 方法。
    • 发现 Socket 可读写时，给对应的 rg，wg 置为 pdReady(1)。
    • 协程调用 poll_runtime_pollWait()。
    • 判断 rg 或 wg 已置为 pdReady(1)，返回 0。
func poll_runtime_pollWait(pd *pollDesc, mode int) int {
    // ...
    // 判断 `rg` 或 `wg` 已置为 pdReady(1)，返回 0。
    for !netpollblock(pd, int32(mode), false) {
        errcode = netpollcheckerr(pd, int32(mode))
        if errcode != pollNoError {
            return errcode
        }
    }
    return pollNoError
}
  • Socket 暂时无法读写时
    • runtime 的 g0 协程循环调用 netpoll() 方法。
    • 协程调用 poll_runtime_pollWait()。
    • 发现对应的 rg 或 wg 为 0。
    • 给对应的 rg 或 wg 置为协程地址。
    • 休眠等待。
    • 当发现 Socket可读写时，查看对应的 rg 或 wg。
    • 若为协程地址，则返回该地址。
    • 调度器开始调度该协程。
      在这里插入图片描述

Socket 通信

net 包中的 Socket 会被定义为一个 netFD 结构体：

type netFD struct {
    // 最终指向的 runtime 中的 Socket 结构体
    pfd poll.FD

    family      int
    sotype      int
    isConnected bool // handshake completed or use of association with peer
    net         string
    laddr       Addr
    raddr       Addr
}

在这里插入图片描述

Server 端

以 TCP 协议为例：

net 的 net.Listen() 操作：

  1. 新建 Socket，并执行 bind 操作
  2. 新建一个 FD（net 包对 Socket 的详情描述）。
  3. 返回一个 TCPListener 对象
  4. 将 TCPListener 的 FD 信息加入监听。
func main() {
    ln, err := net.Listen("tcp", ":8888")
    if err != nil {
        panic(err)
    }
}

TCPListener 本质是一个 LISTEN 状态的 Scoket。

TCPListener.Accept() 操作：

  1. 直接调用 Socket 的 accept()。
  2. 如果失败，休眠等待新的连接。
  3. 将新的 Socket 包装成 TCPConn 变量返回。
  4. 将 TCPConn 的 FD 信息加入监听。
func main() {
    ln, err := net.Listen("tcp", ":8888")
    if err != nil {
        panic(err)
    }

    conn, err := ln.Accept()
    if err != nil {
        panic(err)
    }
    defer conn.Close()
}

TCPConn 本质是一个 ESTANBLISHED 状态的 Scoket。

TCPConn 收发数据

func main() {
    // 1. 监听端口
    ln, err1 := net.Listen("tcp", ":8888")
    if err1 != nil {
        panic(err1)
    }

    // 2. 建立连接
    conn, err2 := ln.Accept()
    if err2 != nil {
        panic(err2)
    }
    defer conn.Close()

    var recv [1024]byte
    // 使用 bufio 标准库提供的缓冲区功能
 send := bufio.NewReader(conn)

    for {

        // 3. 获取数据
        _, err3 := conn.Read(recv[:])
        if err3 != nil {
            break
        }

        fmt.Printf("n: %v\n", string(recv[:]))

        // 4. 发送数据
        msg, err := send.ReadString('\n')
        if strings.ToUpper(msg) == "Q" {
            return
        }
        if err != nil {
            return
        }
        _, err4 := conn.Write([]byte(msg))
        if err4 != nil {
            break
        }
    }
}

Client 端

func main() {
    // 与服务端建立连接
    conn, err := net.Dial("tcp", ":8888")
    if err != nil {
        panic(err)
    }
    
    var recv [1024]byte

    send := bufio.NewReader(os.Stdin)
    for {
        s, _ := send.ReadString('\n')
        if strings.ToUpper(s) == "Q" {
            return  
        }

        // 发送数据
        _, err = conn.Write([]byte(s))
        if err != nil {
            panic(err)
        }

        // 接收数据 
        _, err := conn.Read(recv[:])
        if err != nil {
            break
        }
        fmt.Printf(":%v\n", string(recv[:]))
    }
}

goroutine-per-connection style code

一个协程服务一个新的连接

package main

import (
    "bufio"
    "fmt"
    "net"
    "strings"
)

func handleConnection(conn net.Conn) {
    defer conn.Close()

    var recv [1024]byte
    // 使用 bufio 标准库提供的缓冲区功能
    send := bufio.NewReader(conn)

    for {

        // 3. 获取数据
        _, err3 := conn.Read(recv[:])
        if err3 != nil {
            break
        }

        fmt.Printf("n: %v\n", string(recv[:]))

        // 4. 发送数据
        msg, err := send.ReadString('\n')
        if strings.ToUpper(msg) == "Q" {
            return
        }
        if err != nil {
            return
        }
        _, err4 := conn.Write([]byte(msg))
        if err4 != nil {
            break
        }
    }
}

func main() {
    // 1. 监听端口
    ln, err1 := net.Listen("tcp", ":8888")
    if err1 != nil {
        panic(err1)
    }

    for {
        // 2. 建立连接
        conn, err2 := ln.Accept()
        if err2 != nil {
            panic(err2)
        }

        go handleConnection(conn)
    }
}
码侯烧酒
关注
专栏目录
golang-网络编程
weixin_43867700的博客
11-01 242
网络包发送解析基本过程： osi七层在编程中可以简化为四层分别为： 应用层 传输层 ip网络层 链路层 小知识： netstat -anb 查看本机监听端口 实例： 标准输入代表键盘输入： server.go // net包提供了可移植的网络I/O接口， // 包括TCP/IP、UDP、域名解析和Unix域socket package main i...
golang 语言学习 ：网络编程 理解 （结合例子）
weixin_37076955的博客
07-23 318
关于服务器端与客户端的关系如下： 服务器端： 修路 开辟监听通道（修一条路）路从0.0.0.0:8888这个关口修道软件程序所在地 listen,err:=net.listen(“tcp”,“0,0,0,0:8888”) 2.建立公交车 在8888的门口派一个站岗的，有人人来就用conn 公交车运到目的地 conn,err:=listen.Accept() 沟通， 读取conn带来的东西 因为带来的东西比较特殊，需要用专门的容器接受 []byte 3.1 创建一个容器 buf :=make([]byte,
Golang-网络编程
NINE_world的博客
05-25 541
TCP 服务端 package main import ( "bufio" "fmt" "net" ) // TCP server端 func process(conn net.Conn) { defer conn.Close() // 关闭连接 for { reader := bufio.NewReader(conn) var buf [128]byte // 使用切片接收 n, err := reader.Read(buf[:]) // 读数据 if err != n
Golang 进阶4—— 网络编程
最新发布
weixin_41835324的博客
10-06 810
网络编程： 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统，从而使众多的计算机可以方便的相互通信、共享硬件、软件等资源。
golang--网络编程
zerozhuxiaozhu的博客
06-21 580
beego安装环境： 环境变量： export PATH=$PATH:/usr/local/go/bin export GOPATH=$HOME/workspace export PATH=$PATH:$GOPATH/bin source /etc/profile #是环境变量生效 go get github.com/astaxie/beego #beego安装 go get gi...
Golang网络编程
阿澈不吃蒜的博客
08-30 485
Socket（套接字）是一种用于实现网络通信的编程接口；它允许不同的计算机通过网络互相传递数据；Socket提供了一种标准的编程接口，使得开发者可以使用通用的网络协议（如TCP/IP）进行网络通信。下面举生活中的例子：Socket是应用层与传输层之间的接口，它基于计算机网络原理，将网络传输分为两个角色：服务器（Server）和客户端（Client）CS架构- 服务器端（Server）：服务器端监听特定的网络端口，等待客户端的连接请求。
golang中的网络编程
任性的白菜
02-28 721
1、网络编程 1.1、网络编程基本介绍 1.2、OSI与Tcp/Ip参考模型 1.3、Ip地址 1.4、端口（port）介绍 1.4.1、端口分类 1.4.2、端口（port）使用注意 1.5、tcp socket编程的客户端和服务器端 2、tcp socket编程快速入门 2.1、服务端的处理流程 2.2、客户端的处理流程 2.3、简单的程序示意图 2.4、代码实现 pa...
golang：进行编程练习
02-21
在本文中，我们将深入探讨Go语言，也称为Golang，这是一种由Google开发的现代、高效且简洁的编程语言。Go语言的设计目标是提高开发者的生产力，同时提供高性能和并发支持。如果你正在寻找一种用于编程练习的语言，Go...
积分管理系统java源码-365Golang:《365天深入理解Go语言》
06-06
《365天深入理解Go语言》 一、项目说明 本项目是记录自己在学习Go语言的过程中遇到的思考与感悟。本项目大量参考借鉴甚至是复制了其他类似的项目。感谢每一个项目，致敬每一位Gopher！尽可能的熟练使用Go语言，尽...
golang:gogo
03-31
在IT行业中，Go语言，又称为Golang，是由Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程语言。Go语言的设计灵感来源于C语言，但同时引入了现代编程语言的特性，如内存安全、垃圾回收以及...
【Golang】网络编程
Suk_god的博客
10-04 436
网络编程 网络模型介绍 OSI七层网络模型 在软件开发中我们使用最多的是上图中将互联网划分为五个分层的模型： 物理层 数据链路层 网络层 传输层 应用层 物理层 我们的电脑要与外界互联网通信，需要先把电脑连接网络，我们可以用双绞线、光纤、无线电波等方式。这就叫做”实物理层”，它就是把电脑连接起来的物理手段。它主要规定了网络的一些电气特性，作用是负责传送0和1的电信号 数据链路层 单纯的0和1没有任何意义，所以我们使用者会为其赋予一些特定的含义，规定解读电信号的方式：例如：多少个电信号算
golang 网络编程
云满笔记
06-29 232
golang 网络编程
Golang的网络编程
qq_53267860的博客
02-08 2451
Golang 网络编程 以及 客户端对服务端进行对话
Golang 网络编程
冷月醉雪的博客
02-23 558
TCP服务器 package main import ( "fmt" "log" "net" ) func main() { // net 包提供方便的工具用于 network I/O 开发，包括TCP/IP, UDP 协议等。 // Listen 函数会监听来自 8080 端口的连接，返回一个 net.Listener 对象。 li, er...
Golang-互联网协议&TCP协议
木子阳的工作记录站
05-18 430
OSI七层模型 互联网的逻辑实现被分为好几层。每一层都有自己的功能，就像建筑物一样，每一层都靠下一层支持。用户接触到的只是最上面的那一层，根本不会感觉到下面的几层。要理解互联网就需要自下而上理解每一层的实现的功能。 四层 五层 ...
Golang实现简单的Socket网络编程（代码+详细注释）
u014285914的博客
06-15 2636
Golang实现简单的Socket网络编程（代码+详细注释）
golang:golang学习和项目实战
03-10
在IT行业中，Go语言，又称为Golang，是由Google开发的一种静态类型的、编译型的、并发型且具有垃圾回收功能的编程语言。它旨在提高编程效率，简化系统级编程和网络编程工作，同时保持代码的简洁性和可读性。本资源...
Golang 初识网络编程
chunqizhi
05-28 320
本文通过 Go 语言写几个简单的通信示例，从 TCP 服务器过渡到 HTTP 开发，从而简单介绍 net 包的运用。TCP 服务器首先来看一个 TCP 服务器例子package main import ( "fmt" "log" "net" ) func main() { // net 包提供方便的工具用于 network I/O 开发，包括TCP/IP, UD...
Golang - 网络编程
yang_kaiyue的博客
07-12 238
tcp, udp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值