Networking on Snow

A Deep Dive into Go's Standard Library net Package and TChannel Package

Thu, 09 Apr 2026 11:26:03 +0800

net 包是 Go 语言标准库中网络编程的核心基石，它提供了跨平台的网络 I/O 抽象，支持 TCP/IP、UDP、域名解析、Unix 域套接字等几乎所有主流网络协议。无论是构建简单的客户端 / 服务端，还是开发复杂的分布式系统，net 包都是最底层的支撑工具。

本文档将从基础到高级，全面解析 net 包的核心功能，针对常用功能进行详细展开，并提供可直接运行的实战代码示例。

1. 包概述

net 包的设计理念是统一接口，分层抽象：

高层接口：Dial、Listen、Accept 等通用函数，屏蔽底层协议差异
中层接口：Conn、Listener、PacketConn 等接口，定义通用的读写、监听行为
底层实现：针对 TCP、UDP、IP、Unix 等不同协议的具体实现，提供协议特有的配置能力

大多数场景下，开发者只需要使用高层接口即可完成开发；而在需要精细控制网络行为的场景下，可以深入到底层实现进行调优。

2. 核心基础类型

网络编程的第一步是处理地址，net 包提供了多种地址类型来适配不同的协议。

2.1 IP 地址（`IP` 类型）

IP 类型是一个字节切片，用于表示 IPv4 或 IPv6 地址，它提供了一系列方法来判断地址的属性。

`1`	`type IP []byte`

核心方法与示例

package main

import (
	"fmt"
	"net"
)

func main() {
	// 1. 解析IP地址
	ip := net.ParseIP("192.168.1.100")
	if ip == nil {
		fmt.Println("无效的IP地址")
		return
	}

	// 2. 判断地址类型
	fmt.Println("是否为回环地址:", ip.IsLoopback()) // false
	fmt.Println("是否为私有地址:", ip.IsPrivate())   // true
	fmt.Println("是否为IPv4地址:", ip.To4() != nil)  // true
	// To4方法会返回IPv4地址的4字节表示，如果不是IPv4地址则返回nil；To16方法会返回IPv6地址的16字节表示，如果不是IPv6地址则返回nil。

	// 3. 构造IPv4地址
	ipv4 := net.IPv4(127, 0, 0, 1)
	fmt.Println("回环地址:", ipv4.String()) // 127.0.0.1

	// 4. 掩码计算
	ip2 := net.ParseIP("192.168.1.100")
	mask := net.IPv4Mask(255, 255, 255, 0)
	networkIP := ip2.Mask(mask)
	fmt.Println("网段地址:", networkIP.String()) // 192.168.1.0
}

2.2 IP 网段（`IPNet` 类型）

IPNet 用于表示一个 IP 网段，常用于判断某个 IP 是否属于某个子网，这在防火墙、路由匹配等场景中非常常用。

核心方法与示例

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	// 1. 解析CIDR格式的网段
	ip, ipNet, err := net.ParseCIDR("192.168.1.50/24")
	if err != nil {
		log.Fatal(err)      // 解析失败，CIDR格式不正确，或者IP地址无效。
		// log.Fatal会导致程序崩溃，适合在示例代码中使用，但在生产环境中应该使用更优雅的错误处理方式，如log.Printf或返回错误给调用者。
	}

	fmt.Println("IP地址:", ip.String())       // 192.168.1.0
	fmt.Println("网段:", ipNet.String())        // 192.168.1.0/24

	// 2. 判断IP是否属于该网段
	testIP := net.ParseIP("192.168.1.100")
	fmt.Println(testIP.String(), "是否在网段内：", ipNet.Contains(testIP)) // true

	testIP2 := net.ParseIP("8.8.8.8")
	fmt.Println(testIP2.String(), "是否在网段内：", ipNet.Contains(testIP2)) // false
}

2.3 传输层地址（TCPAddr/UDPAddr）

TCP 和 UDP 地址都包含 IP 和端口两部分，用于标识网络中的一个端点。

地址解析示例

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	// 解析TCP地址
	tcpAddr, err := net.ResolveTCPAddr("tcp", "localhost:8080")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("TCP地址:", tcpAddr.String()) // 127.0.0.1:8080

	// 解析UDP地址
	udpAddr, err := net.ResolveUDPAddr("udp", "localhost:8080")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("UDP地址:", udpAddr.String()) // 127.0.0.1:8080
}

2.4 地址处理工具函数

处理 host:port 格式的地址时，JoinHostPort 和 SplitHostPort 是最常用的工具，它们能正确处理 IPv6 地址的括号格式。

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	// 拼接主机和端口
	host := "127.0.0.1"
	port := "8080"
	addr := net.JoinHostPort(host, port)
	fmt.Println("拼接后地址:", addr) // 127.0.0.1:8080

	// 拆分地址
	host2, port2, err := net.SplitHostPort(addr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("拆分后主机:", host2, "端口:", port2)

	// 正确处理IPv6地址
	ipv6Addr := "[::1]:8080"
	host3, port3, _ := net.SplitHostPort(ipv6Addr)
	fmt.Println("IPv6拆分后主机:", host3, "端口:", port3) // ::1 8080
}

3. TCP 网络编程（面向连接可靠传输）

TCP 是面向连接的可靠传输协议，是互联网中最常用的传输层协议。net 包通过 TCPListener 和 TCPConn 来实现 TCP 通信。

3.1 基础 TCP 服务端

TCP 服务端的工作流程是：监听端口 -> 接受连接 -> 处理连接。Go 中通过 goroutine 可以轻松实现高并发的服务端。

package main

import (
	"bufio"     // 提供了缓冲读取和写入功能，适用于网络连接的读写操作，可以按行读取数据。
	"fmt"
	"net"
	"log"
)

func handleConnection(conn *net.TCPConn) {
	// 确保连接关闭
	defer conn.Close()
	log.Printf("客户端 %s 已连接", conn.RemoteAddr())

	// 读取客户端数据
	reader := bufio.NewReader(conn)
	for {
		// 按行读取数据
		data, err := reader.ReadString('\n')
		if err != nil {
			log.Printf("客户端 %s 已断开", conn.RemoteAddr())
			return
		}

		log.Printf("收到来自 %s 的消息: %s", conn.RemoteAddr(), data)
		// 回显消息
		_, err = conn.Write([]byte("Echo: " + data))
		if err != nil {
			log.Printf("发送数据失败: %v", err)
			return
		}
	}
}

func main() {
	// 解析监听地址
	addr, err := net.ResolveTCPAddr("tcp", ":8080") // 监听8080端口
	if err != nil {
		log.Println(err.Error())
		return
	}

	// 监听端口
	listener, err := net.ListenTCP("tcp", addr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer listener.Close()
	log.Println("TCP服务端已启动，监听 :8080")

	for {
		// 接受新连接
		conn, err := listener.AcceptTCP()
		if err != nil {
			log.Printf("接受连接失败: %v", err)
			continue
		}

		// 启动goroutine处理连接，实现并发
		go handleConnection(conn)
	}
}

3.2 基础 TCP 客户端

TCP 客户端通过主动连接服务端来建立连接，然后进行数据读写。

package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"log"
)

func main() {
	// 连接服务端，中间这个nil表示本地地址，通常设置为nil让系统自动分配一个可用的端口。
	conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8080})
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	log.Println("已连接到服务端")

	// 从标准输入读取消息
	scanner := bufio.NewScanner(os.Stdin)   // 从标准输入读取用户输入，os.Stdin表示标准输入设备，通常是键盘。
	writer := bufio.NewWriter(conn)         
	// 创建一个缓冲写入器，用于向TCP连接写数据，它会将数据先写入内存缓冲区，只有在调用Flush方法时才会真正发送到网络上，这样可以提高效率，减少系统调用次数。
	// conn是之前建立的TCP连接，bufio.NewWriter(conn)创建了一个新的缓冲写入器，将TCP连接作为底层的写入目标。

	for scanner.Scan() {
		text := scanner.Text()
		// 发送消息
		_, err = writer.WriteString(text + "\n")
		if err != nil {
			log.Println(err.Error())
		return
		}
		writer.Flush()

		// 读取响应
		resp, err := bufio.NewReader(conn).ReadString('\n') // 以换行符为分隔符读取服务端响应，直到遇到换行符为止。
		if err != nil {
			log.Println(err.Error())
		return
		}
		fmt.Println("服务端响应:", resp)
	}
}

如此即可实现一个简单的 TCP 客户端，能够向服务端发送消息并接收响应。

3.3 TCP 连接高级配置

TCPConn 提供了一系列方法来调整 TCP 协议的参数，以适配不同的业务场景。

3.3.1 禁用 Nagle 算法（`SetNoDelay`）

Nagle 算法是 TCP 协议中的一个优化机制，它会将小数据包合并成一个大数据包发送，以减少网络开销。但在某些实时性要求高的场景下（如在线游戏、即时通信），这种合并会引入不必要的延迟，因此需要禁用 Nagle 算法。

Nagle 算法默认会合并小数据包以减少网络开销，但会引入延迟。对于实时性要求高的场景（如游戏、即时通信），需要禁用它。

// 建立连接后
conn, err := net.DialTCP("tcp", nil, serverAddr)
if err != nil {
	log.Println(err.Error())
		return
}

// 禁用Nagle算法，小数据包立即发送
err = conn.SetNoDelay(true)
if err != nil {
	log.Printf("设置NoDelay失败: %v", err)
}

3.3.2 TCP 保活机制（`SetKeepAlive`）

TCP 保活机制可以自动检测死连接，避免长时间占用资源。Go 1.13+ 还支持更精细的保活配置。

// 启用保活机制
err = conn.SetKeepAlive(true)
if err != nil {
	log.Printf("启用保活失败: %v", err)
}

// 方式1：简单设置保活间隔（旧API）
err = conn.SetKeepAlivePeriod(30 * time.Second)
if err != nil {
	log.Printf("设置保活间隔失败: %v", err)
}

// 方式2：精细配置保活参数（Go 1.13+ 新API）
err = conn.SetKeepAliveConfig(net.KeepAliveConfig{
	Enable:   true,
	Idle:     30 * time.Second,  // 空闲30秒后开始发送探针
	Interval: 10 * time.Second,  // 探针间隔10秒
	Count:    3,                 // 连续3次失败则断开连接
})
if err != nil {
	log.Printf("设置保活配置失败: %v", err)
}

3.3.3 连接半关闭

TCP 支持半关闭，即可以单独关闭读或写通道，这在某些场景下非常有用（比如发送完数据后告诉服务端不再发送，但还能接收响应）。

// 发送完所有数据后，关闭写通道
err = conn.CloseWrite()
if err != nil {
	log.Printf("关闭写通道失败: %v", err)
}

// 此时还可以继续读取服务端的响应
data, err := conn.Read(buf)

// 读取完后，关闭读通道
err = conn.CloseRead()

4. UDP 网络编程（无连接数据报传输）

UDP 是无连接的传输协议，不需要建立连接，直接发送数据包，适用于对实时性要求高、可容忍少量丢包的场景（如音视频、心跳检测）。

4.1 基础 UDP 服务端

package main

import (
	"fmt"
	"net"
	"log"
)

func main() {
	// 解析UDP地址
	addr, err := net.ResolveUDPAddr("udp", ":8080")
	if err != nil {
		log.Println(err.Error())
		return
	}

	// 监听UDP端口
	conn, err := net.ListenUDP("udp", addr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()
	log.Println("UDP服务端已启动，监听 :8080")

	buf := make([]byte, 1024)
	for {
		// 读取UDP数据包，同时获取客户端地址
		n, clientAddr, err := conn.ReadFromUDP(buf)
		if err != nil {
			log.Printf("读取数据失败: %v", err)
			continue
		}

		data := string(buf[:n])
		log.Printf("收到来自 %s 的消息: %s", clientAddr, data)

		// 向客户端发送响应
		resp := []byte("UDP Ack: " + data)
		_, err = conn.WriteToUDP(resp, clientAddr)
		if err != nil {
			log.Printf("发送响应失败: %v", err)
		}
	}
}

4.2 基础 UDP 客户端

package main

import (
	"fmt"
	"net"
	"log"
)

func main() {
	// 服务端地址
	serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8080")
	if err != nil {
		log.Println(err.Error())
		return
	}

	// 建立UDP连接（UDP的连接只是逻辑绑定，不发送网络包）,中间这个nil表示本地地址，通常设置为nil让系统自动分配一个可用的端口。
	conn, err := net.DialUDP("udp", nil, serverAddr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	// 发送数据
	_, err = conn.Write([]byte("Hello UDP Server!"))
	if err != nil {
		log.Println(err.Error())
		return
	}

	// 读取响应
	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil {
		log.Println(err.Error())
		return
	}

	fmt.Println("服务端响应:", string(buf[:n]))
}

如此即可实现一个简单的 UDP 客户端，能够向服务端发送消息并接收响应。

4.3 实战：UDP 心跳检测

UDP 非常适合做心跳检测，因为它轻量、无连接开销。

package main

import (
	"net"
	"time"
	"log"
)

func main() {
	serverAddr, _ := net.ResolveUDPAddr("udp", "127.0.0.1:8080")
	conn, _ := net.DialUDP("udp", nil, serverAddr)
	defer conn.Close()

	// 定时器，每秒发送一次心跳
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()

	for range ticker.C {
		// 发送心跳包
		_, err := conn.Write([]byte("HEARTBEAT"))
		if err != nil {
			log.Printf("发送心跳失败: %v", err)
			continue
		}

		// 设置读取超时，检测服务端是否存活
		conn.SetReadDeadline(time.Now().Add(2 * time.Second))
		buf := make([]byte, 1024)
		n, err := conn.Read(buf)
		if err != nil {
			log.Printf("心跳检测失败，服务端可能已下线: %v", err)
			continue
		}

		log.Printf("心跳正常，服务端响应: %s", string(buf[:n]))
	}
}

如图所示，UDP 心跳检测可以快速判断服务端的存活状态，适用于分布式系统中的健康检查和服务发现。

5. DNS 域名解析

net 包提供了完整的 DNS 解析能力，从基础的域名转 IP，到高级的 MX、SRV、TXT 记录查询。

5.1 基础域名解析

package main

import (
	"fmt"
	"net"
	"log"
)

func main() {
	// 解析域名对应的IP列表（同时返回IPv4和IPv6）
	ips, err := net.LookupIP("google.com")
	if err != nil {
		log.Println(err.Error())
		return
	}

	for _, ip := range ips {
		fmt.Println("IP地址:", ip.String())
	}

	// 反向解析：根据IP查找域名
	names, err := net.LookupAddr("8.8.8.8")
	if err != nil {
		log.Println(err.Error())
		return
	}
	for _, name := range names {
		fmt.Println("8.8.8.8对应的域名:", name)
	}
}

解析结果如下图所示：

5.2 高级 DNS 记录查询

package main

import (
	"fmt"
	"net"
	"log"
)

func main() {
	// 1. 查询MX记录（邮件服务器记录）。MX记录是Mail Exchanger Record的缩写，邮件交换记录，用于指定处理该域邮件的服务器地址和优先级。
	mxs, err := net.LookupMX("gmail.com")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("Gmail的邮件服务器:")
	for _, mx := range mxs {
		fmt.Printf("  优先级: %d, 服务器: %s\n", mx.Pref, mx.Host)
	}

	// 2. 查询SRV记录（服务发现记录，常用于微服务）。SRV记录是Service Record的缩写，用于指定提供特定服务的服务器地址、端口和优先级，常用于微服务架构中的服务发现。
	cname, srvs, err := net.LookupSRV("xmpp-server", "tcp", "gmail.com")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("\nXMPP服务的SRV记录:")
	fmt.Println("CNAME:", cname)
	for _, srv := range srvs {
		fmt.Printf("  目标: %s:%d, 优先级: %d, 权重: %d\n", srv.Target, srv.Port, srv.Priority, srv.Weight)
	}

	// 3. 查询TXT记录（常用于验证域名、SPF、DKIM等）。TXT记录是Text Record的缩写，用于存储任意文本信息，常用于域名验证、SPF（Sender Policy Framework）和DKIM（DomainKeys Identified Mail）等邮件安全机制。
	txts, err := net.LookupTXT("gmail.com")
	if err != nil {
		log.Println(err.Error())
		return
	}
	fmt.Println("\nTXT记录:")
	for _, txt := range txts {
		fmt.Println("  ", txt)
	}
}

查询结果如下图所示：

5.3 自定义 DNS 解析器

默认情况下，net 包使用系统的 DNS 配置，但我们可以自定义 DNS 服务器，比如使用 Google DNS 或 Cloudflare DNS。

package main

import (
	"context"
	"fmt"
	"net"
	"time"
)

func main() {
	// 自定义DNS解析器，使用Google的8.8.8.8
	resolver := &net.Resolver{
		// 强制使用Go原生的DNS解析器，不使用系统的cgo解析
		PreferGo: true,
		// 自定义DNS服务器的连接
		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
			d := net.Dialer{
				Timeout: 3 * time.Second,
			}
			// 连接到自定义的DNS服务器
			return d.DialContext(ctx, "udp", "8.8.8.8:53")
		},
	}

	// 使用自定义解析器解析域名
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	ips, err := resolver.LookupIP(ctx, "ip4", "google.com")
	if err != nil {
		log.Println(err.Error())
		return
	}

	for _, ip := range ips {
		fmt.Println("通过8.8.8.8解析到的IP:", ip.String())
	}
}

解析结果如下图所示：

6. 错误处理与超时控制

网络编程中，错误处理和超时控制是保证服务稳定性的关键。

6.1 网络错误类型（`net.Error`）

net 包的所有网络错误都实现了 net.Error 接口，它提供了 Timeout() 和 Temporary() 方法来区分错误类型。

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
    // 这里用google.com:80作为测试地址，设置一个非常短的超时时间来触发错误
	conn, err := net.DialTimeout("tcp", "google.com:80", 1*time.Second)
	if err != nil {
		// 判断错误是否为网络错误
		if ne, ok := err.(net.Error); ok {
			fmt.Println("是否为超时错误:", ne.Timeout())
			fmt.Println("是否为临时错误:", ne.Temporary())
		}
		fmt.Println("错误信息:", err)
		return
	}
	defer conn.Close()
	fmt.Println("连接成功")
}

之所以 Timeout() 和 Temporary() 都返回 true，是因为在这个场景下，连接超时被认为是一个临时错误，可能是网络状况不佳导致的，重试可能会成功。

6.2 超时控制详解

net 包提供了多层级的超时控制：

1. 连接超时

在建立连接时设置超时，避免长时间卡在连接阶段。

// 方式1：使用DialTimeout
conn, err := net.DialTimeout("tcp", "google.com:80", 5*time.Second)

// 方式2：使用Dialer+Context
d := net.Dialer{Timeout: 5*time.Second}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
conn, err := d.DialContext(ctx, "tcp", "google.com:80")

2. 读写超时

连接建立后，为读写操作设置超时，避免单个读写操作阻塞。

// 统一设置读写超时
conn.SetDeadline(time.Now().Add(30 * time.Second))

// 单独设置读超时
conn.SetReadDeadline(time.Now().Add(10 * time.Second))

// 单独设置写超时
conn.SetWriteDeadline(time.Now().Add(10 * time.Second))

7. 高级连接配置：`Dialer`

Dialer 是 net 包中用于配置连接的核心结构体，它可以统一配置连接的超时、保活、DNS 解析器等参数。

7.1 Dialer 核心配置

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"time"
)

func main() {
	// 配置Dialer
	dialer := &net.Dialer{
		// 连接超时：如果在指定时间内无法建立连接，则返回错误
		Timeout:   5 * time.Second,
		// 保活间隔：每隔30秒发送一次TCP保活探针
		KeepAlive: 30 * time.Second,
		// 本地地址，用于指定出站网卡
		LocalAddr: nil,
		// 自定义DNS解析器
		Resolver: &net.Resolver{
            // 强制使用Go原生的DNS解析器，不使用系统的cgo解析
			PreferGo: true,
            // 自定义DNS服务器的连接
			Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
				return net.Dial("udp", "8.8.8.8:53")
			},
		},
	}

	// 使用Dialer建立连接
	conn, err := dialer.DialContext(context.Background(), "tcp", "google.com:80")
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	fmt.Println("连接成功")
}

如果连不上会得到以下输出：

如果连接成功会得到以下输出：

8. Unix 域套接字（本地进程间通信）

Unix 域套接字是用于同一主机上进程间通信的机制，比 TCP 更快，不需要经过网络协议栈，延迟更低。

8.1 流式 Unix 域套接字（类似 TCP）

// 服务端
package main

import (
	"net"
	"os"
	"log"
)

func main() {
	sockPath := "/tmp/test.sock"
	// 清理旧的sock文件
	os.Remove(sockPath)

	// 监听Unix域套接字
	listener, err := net.Listen("unix", sockPath)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer listener.Close()
	defer os.Remove(sockPath)

	log.Println("Unix服务端已启动")

	for {
		conn, err := listener.Accept()
		if err != nil {
			continue
		}
		go func(c net.Conn) {
			defer c.Close()
			// 处理连接，和TCP完全一样
			buf := make([]byte, 1024)
			n, _ := c.Read(buf)
			c.Write([]byte("Echo: " + string(buf[:n])))
		}(conn)
	}
}

// 客户端
package main

import (
	"fmt"
	"net"
)

func main() {
	// 连接Unix域套接字
	conn, err := net.Dial("unix", "/tmp/test.sock")
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	conn.Write([]byte("Hello IPC!"))
	buf := make([]byte, 1024)
	n, _ := conn.Read(buf)
	fmt.Println(string(buf[:n]))
}

9. 原始 IP 与 ICMP：实现 Ping 工具

通过 net 包的原始 IP 连接，我们可以实现 ICMP 协议，也就是常用的 ping 工具。

注意：ICMP 原始套接字在部分系统上需要 root 权限。

package main

import (
	"fmt"
	"net"
	"time"
)

// 计算ICMP校验和
func checkSum(msg []byte) uint16 {
	sum := 0
	for i := 0; i < len(msg)-1; i += 2 {
		sum += int(msg[i])*256 + int(msg[i+1])
	}
	sum = (sum >> 16) + (sum & 0xffff)
	sum += sum >> 16
	return uint16(^sum)
}

func ping(host string) error {
	// 建立ICMP连接
	conn, err := net.Dial("ip4:icmp", host)
	if err != nil {
		return err
	}
	defer conn.Close()

	// 构造ICMP Echo请求包
	msg := make([]byte, 64)
	msg[0] = 8 // Type: Echo Request
	msg[1] = 0 // Code: 0
	// Checksum占位
	msg[2] = 0
	msg[3] = 0
	// Identifier
	id := uint16(1234)
	msg[4] = byte(id >> 8)
	msg[5] = byte(id & 0xff)
	// Sequence
	seq := uint16(1)
	msg[6] = byte(seq >> 8)
	msg[7] = byte(seq & 0xff)

	// 计算校验和
	sum := checkSum(msg)
	msg[2] = byte(sum >> 8)
	msg[3] = byte(sum & 0xff)

	start := time.Now()
	// 发送ICMP包
	_, err = conn.Write(msg)
	if err != nil {
		return err
	}

	// 设置超时
	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
	recv := make([]byte, 1024)
	n, err := conn.Read(recv)
	if err != nil {
		return err
	}

	duration := time.Since(start)
	// 解析响应，ICMP响应的Type为0
	if recv[20] == 0 { // 跳过20字节IP头
		fmt.Printf("%s is up, 延迟: %v\n", host, duration)
		return nil
	}
	return fmt.Errorf("收到非预期的响应")
}

func main() {
	err := ping("8.8.8.8")
	if err != nil {
		fmt.Println("Ping失败:", err)
	}
}

10. 网络接口与本机信息获取

net 包还提供了获取本机网卡、IP 信息的能力。

获取本机所有非回环 IP

package main

import (
	"fmt"
	"net"
)

func main() {
	// 获取所有网络接口的地址
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		log.Println(err.Error())
		return
	}

	for _, addr := range addrs {
		// 转换为IPNet
		if ipNet, ok := addr.(*net.IPNet); ok {
			// 排除回环地址
			if !ipNet.IP.IsLoopback() {
				// 只打印IPv4地址
				if ipNet.IP.To4() != nil {
					fmt.Println("本机IP:", ipNet.IP.String())
				}
			}
		}
	}
}

11. 其他常用工具示例

11.1 简单端口扫描

通过 DialTimeout 我们可以快速实现一个简单的端口扫描工具，检测目标主机的端口是否开放。

package main

import (
	"fmt"
	"net"
	"sync"
	"time"
)

func main() {
	target := "localhost"
	var wg sync.WaitGroup

	// 扫描1-1024端口
	for port := 1; port <= 1024; port++ {
		wg.Add(1)
		go func(p int) {
			defer wg.Done()
			address := fmt.Sprintf("%s:%d", target, p)
			// 用500ms超时检测端口
			conn, err := net.DialTimeout("tcp", address, 500*time.Millisecond)
			if err == nil {
				fmt.Printf("端口 %d 开放\n", p)
				conn.Close()
			}
		}(port)
	}
	wg.Wait()
	fmt.Println("扫描完成")
}

11.2 内存管道 Pipe

Pipe 函数可以创建一对内存中的连接，用于进程内的通信，它实现了 net.Conn 接口，所以可以像网络连接一样进行读写。

package main

import (
	"fmt"
	"net"
)

func main() {
	// 创建内存管道
	r, w := net.Pipe()

	// 写入端goroutine
	go func() {
		defer w.Close()
		// 写入数据
		_, err := w.Write([]byte("Hello from Pipe!"))
		if err != nil {
			log.Println(err.Error())
		return
		}
	}()

	// 读取端
	buf := make([]byte, 1024)
	n, err := r.Read(buf)
	if err != nil {
		log.Println(err.Error())
		return
	}

	fmt.Println("读取到的数据:", string(buf[:n]))
}

11.3 Go 1.26 新特性：Dialer 新方法

Go 1.26 为 Dialer 新增了针对特定协议的方法，比如 DialTCP、DialUDP，这些方法支持预解析的地址，兼顾了预解析的效率和 context 的可取消性。

package main

import (
	"context"
	"fmt"
	"net"
	"net/netip"
	"time"
)

func main() {
	// 预解析地址，避免每次连接都解析
	raddr := netip.MustParseAddrPort("127.0.0.1:8080")

	dialer := &net.Dialer{
		Timeout: 5 * time.Second,
	}

	// 使用新的DialTCP方法，支持context
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	conn, err := dialer.DialTCP(ctx, "tcp", netip.AddrPort{}, raddr)
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer conn.Close()

	fmt.Println("连接成功")
}

11.4 自定义 DNS 在 HTTP 客户端中的应用

我们可以将自定义的 DNS 解析器和 HTTP 客户端结合，让 HTTP 请求也使用自定义的 DNS 服务器。

package main

import (
	"context"
	"fmt"
	"net"
	"net/http"
	"io/ioutil"
	"time"
)

func main() {
	// 自定义DNS解析器，使用Cloudflare的1.1.1.1
	resolver := &net.Resolver{
		PreferGo: true,
		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
			d := net.Dialer{Timeout: 3 * time.Second}
			return d.DialContext(ctx, "udp", "1.1.1.1:53")
		},
	}

	// 自定义Transport的DialContext
	transport := &http.Transport{
		DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
			// 拆分主机和端口
			host, port, err := net.SplitHostPort(addr)
			if err != nil {
				return nil, err
			}

			// 用自定义解析器解析主机
			ips, err := resolver.LookupHost(ctx, host)
			if err != nil {
				return nil, err
			}

			// 逐个尝试连接解析到的IP
			for _, ip := range ips {
				dialer := &net.Dialer{Timeout: 5 * time.Second}
				conn, err := dialer.DialContext(ctx, network, net.JoinHostPort(ip, port))
				if err == nil {
					return conn, nil
				}
			}
			return nil, fmt.Errorf("所有IP连接失败")
		},
	}

	// 创建使用自定义DNS的HTTP客户端
	client := &http.Client{
		Transport: transport,
		Timeout:   10 * time.Second,
	}

	// 发送请求
	resp, err := client.Get("https://example.com")
	if err != nil {
		log.Println(err.Error())
		return
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println("响应状态:", resp.Status)
	fmt.Println("响应长度:", len(body))
}

12. 避坑指南

始终处理错误：网络操作的错误必须处理，不能忽略，尤其是 Accept、Read、Write 这些核心操作。
资源释放：使用 defer conn.Close() 确保连接关闭，避免文件描述符泄漏。
超时控制：所有网络操作都要设置超时，避免阻塞导致服务不可用。
并发处理：TCP 服务端必须用 goroutine 处理每个连接，才能实现高并发。
参数调优：
- 实时场景：禁用 Nagle 算法（SetNoDelay(true)）
- 长连接场景：启用 TCP 保活，快速检测死连接
- 批量传输：保持 Nagle 算法，增大读写缓冲区，提升吞吐量
DNS 缓存：默认的 DNS 解析没有缓存，高并发场景下建议自己实现 DNS 缓存，避免频繁解析。
Unix 域套接字：本地进程间通信优先使用 Unix 域套接字，比 TCP 性能更好。

通过以上内容，你已经基本掌握了 Go net 包的核心用法，从基础的 TCP/UDP 通信，到高级的 DNS 解析、ICMP 实现，都可以基于此进行开发。无论是构建简单的网络工具，还是开发复杂的分布式系统，net 包都是你不可或缺的利器。希望这份文档能帮助你更好地理解和使用 Go 的网络编程能力！

TCP/IP Protocol Stack Interview Questions (Continuously Updated)

Wed, 25 Mar 2026 22:14:11 +0800

本文档整理了后端开发、客户端开发等技术岗位面试中，关于 TCP/IP 协议栈及核心网络协议最常被问到的高频面试题和深度解析。

一、网络模型基础

1. 讲一下 OSI 七层模型、TCP/IP 四层模型和五层体系结构？

OSI 七层模型（从上到下）：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层。（理论模型，实际未广泛应用）
TCP/IP 四层模型（从上到下）：应用层、传输层、网际层（网络层）、网络接口层。（实际广泛应用的模型）
五层体系结构（学习专用，从上到下）：应用层、传输层、网络层、数据链路层、物理层。

各层核心功能及常见协议：

应用层：为用户提供应用接口，解决特定网络应用问题。（HTTP, HTTPS, FTP, DNS, SMTP, POP3）
传输层：为两台主机中的进程提供通用的数据传输服务。（TCP, UDP）
网络层：负责为分组交换网上的不同主机提供通信服务，路由选择。（IP, ICMP, ARP, OSPF, BGP）
数据链路层：将网络层交下来的 IP 数据报组装成帧，在相邻节点的链路上传送。（以太网协议、PPP）
物理层：透明地传送比特流。（RJ45等）

二、 TCP 与 UDP 基础

2. TCP 和 UDP 的区别是什么？

特性	TCP (Transmission Control Protocol)	UDP (User Datagram Protocol)
连接性	面向连接（需三次握手）	无连接（直接发）
可靠性	可靠传输（不丢包、不乱序）	不可靠传输（尽最大努力交付，可能丢包）
工作方式	字节流（会出现粘包拆包问题）	数据报文（报文边界明确）
传输效率	较慢（开销大，有头部、确认、重传机制）	较快（开销小）
头部大小	至少 20 字节，可变	8 字节（固定）
拥塞控制/流量控制	有	无
适用场景	文件传输、HTTP/HTTPS、邮件（要求准确无误）	视频流媒体、直播、DNS查询、实时游戏（要求实时性）

补充：TCP 是面向进程的连接，而 UDP 是面向主机的无连接协议。
TCP 通过序列号、确认应答、重传机制保证可靠性，而 UDP 则不提供这些机制，完全依赖应用层来处理丢包和乱序问题。
TCP 的头部包含更多字段（如序列号、确认号、窗口大小等）来支持可靠传输和流量控制，而 UDP 的头部非常简洁，仅包含源端口、目的端口、长度和校验和。
粘包拆包问题：TCP 是字节流协议，发送方连续发送多个报文时，接收方可能会将它们合并成一个报文（粘包）或将一个报文分成多个部分接收（拆包）。这可能会导致数据解析问题。UDP 是数据报协议，每个报文独立传输，不存在粘包拆包问题。

三、 TCP 连接管理（绝对重点）

3. 请详细画出/描述 TCP 的三次握手过程？

三次握手是为了建立可靠的连接，同步双方的序列号和窗口大小。

第一次握手（Client -> Server）：客户端生成一个随机序列号 seq = x，并把标志位 SYN 设为 1。客户端进入 SYN_SENT 状态。此时报文不携带数据。
第二次握手（Server -> Client）：服务端收到 SYN 报文，同意建立连接，生成自己的随机序列号 seq = y，并将确认号 ack = x + 1，同时将 SYN 和 ACK 标志位都设为 1。服务端进入 SYN_RCVD 状态。
第三次握手（Client -> Server）：客户端收到服务端的 SYN+ACK 报文，检查 ack 是否为 x+1。如果正确，则将标志位 ACK 设为 1，确认号 ack = y + 1。客户端进入 ESTABLISHED 状态。服务端收到后也进入 ESTABLISHED 状态，连接建立。此报文可以携带数据。

4. 为什么是三次握手？两次不行吗？四次不行吗？

为什么不能是两次？（防止已失效的连接请求报文段突然又传送到了服务端）
假设客户端发送了第一个 SYN 报文（因为网络延迟滞留了），客户端超时后重发了第二个 SYN 并完成了两次握手建立连接，数据传完后断开。此时，第一个滞留的 SYN 终于到了服务端。如果是两次握手，服务端会以为客户端又要建立连接，直接单方面进入 ESTABLISHED 状态并分配资源，导致服务端资源浪费（即“历史连接”问题）。三次握手可以让客户端在第三步拒绝这个历史连接。
为什么不需要四次？
服务端的确认报文（ACK）和同步报文（SYN）是可以合并在一起发送的（即第二次握手），没必要拆成两步，所以三次足够了。

5. 请详细画出/描述 TCP 的四次挥手过程？

由于 TCP 是全双工的，因此每个方向都必须单独进行关闭。

第一次挥手（Client -> Server）：客户端应用进程发出连接释放报文，FIN = 1, seq = u。客户端进入 FIN_WAIT_1 状态。表示客户端没有数据要发了。
第二次挥手（Server -> Client）：服务端收到 FIN，发出确认报文 ACK = 1, ack = u + 1, seq = v。服务端进入 CLOSE_WAIT 状态。此时 TCP 连接处于半关闭状态，客户端不能发数据，但服务端如果还有数据没发完，可以继续发。客户端收到 ACK 后进入 FIN_WAIT_2 状态。
第三次挥手（Server -> Client）：服务端数据发送完毕，发出连接释放报文，FIN = 1, ACK = 1, seq = w, ack = u + 1。服务端进入 LAST_ACK 状态。
第四次挥手（Client -> Server）：客户端收到 FIN 后，发出确认报文 ACK = 1, ack = w + 1, seq = u + 1。客户端进入 TIME_WAIT 状态。服务端收到 ACK 后进入 CLOSED 状态。客户端经过 2MSL 时间后，也进入 CLOSED 状态。

6. 为什么挥手需要四次，而握手只需要三次？

因为 TCP 是全双工通信。握手时，服务端的 SYN 和 ACK 可以一起发送。但挥手时，当收到对方的 FIN 报文时，仅仅表示对方不再发送数据了，但接收方自己可能还有数据需要发送。所以接收方先回复一个 ACK，等自己数据发送完毕后，再发送 FIN 报文。因此通常需要四次。

7. 什么是 TIME_WAIT 状态？为什么需要等待 2MSL？

TIME_WAIT 是主动关闭连接的一方在发送完最后一个 ACK 后进入的状态。等待 2MSL（最大报文生存时间的2倍）原因有二：

保证可靠关闭：如果最后的 ACK 丢失，服务端会重传 FIN。客户端在 2MSL 内可再次收到 FIN 并重发 ACK。重发之后 TIME_WAIT 计时器重置，继续等待，直到 2MSL 超时后才真正关闭连接。
防止“已失效报文”干扰：保证本次连接的所有报文从网络中消失，不会影响后续的新连接。

8. 为什么 TIME_WAIT 的时间是 2MSL？为什么不是 MSL 或者 3MSL？

MSL 是指网络中一个报文的最大生存时间。等待 2MSL 的原因是：

保证可靠关闭：如果最后的 ACK 丢失，服务端会重传 FIN。客户端在 2MSL 内可再次收到 FIN 并重发 ACK。重发之后 TIME_WAIT 计时器重置，继续等待，直到 2MSL 超时后才真正关闭连接。
防止“已失效报文”干扰：保证本次连接的所有报文从网络中消失，不会影响后续的新连接。如果只等待 MSL，可能会有未消失的报文干扰后续连接；如果等待 3MSL，虽然更安全，但会增加资源占用和连接关闭的延迟，2MSL 是一个权衡的选择。

9. TIME_WAIT 状态会导致什么问题？如何解决？

TIME_WAIT 状态会导致服务器资源被占用，尤其是在高并发场景下，可能出现大量 TIME_WAIT 连接，导致服务器无法接受新的连接请求（即“端口耗尽”问题）。解决方法有：

调整操作系统参数：如 Linux 中可以通过修改 /proc/sys/net/ipv4/tcp_tw_reuse 和 /proc/sys/net/ipv4/tcp_tw_recycle 来允许重用 TIME_WAIT 状态的连接（但这可能会引入安全风险）。
使用负载均衡：将请求分散到多个服务器上，减少单台服务器的连接压力。
优化应用层协议：如使用 HTTP/2 的长连接，减少连接的建立和关闭次数。
使用 UDP：对于一些不需要可靠传输的场景，可以考虑使用 UDP，避免 TCP 的连接管理开销。

四、 TCP 可靠传输与控制

10. TCP 是如何保证可靠传输的？

TCP 保证可靠传输主要依靠：

数据分块与校验和：验证数据在传输过程中是否损坏。
序列号与确认应答 (Seq & ACK)：保证数据不乱序、不丢失。
超时重传机制：未在 RTO(Retransmission Timeout，超时重传时间) 内收到 ACK，则重新发送。
连接管理：三次握手、四次挥手。
流量控制（滑动窗口）：控制发送速度，防止接收缓冲区溢出。
拥塞控制：网络拥塞时减少发送量。

11. 详细说说 TCP 的拥塞控制？

拥塞控制包含四个算法：

慢启动：刚建立连接时，拥塞窗口 cwnd 较小，随后每经过一个 RTT 呈指数级增长，直到达到阈值 ssthresh。
拥塞避免：当 cwnd >= ssthresh 时，每经过一个 RTT cwnd 加 1，呈线性增长。
快速重传：收到连续 3 个相同的重复 ACK 时，立刻重传丢失报文，不等待超时。
快速恢复：配合快速重传，将 ssthresh 减半，cwnd 设为 ssthresh，进入拥塞避免阶段。(注：超时丢包通常回退到慢启动)

为什么收到连续 3 个重复 ACK 就认为丢包了？因为 TCP 是基于 ACK 来确认数据的，如果连续收到 3 个相同的 ACK，说明后续的数据包已经到达了，但某个数据包丢失了，导致 ACK 没有更新。这个机制比等待超时更快地检测到丢包，提高了传输效率。

五、网络层与其他核心协议

12. IP 协议是干什么的？IPv4 和 IPv6 的区别？

IP 协议负责在网络中进行路由寻址和数据包的分片。它提供了无连接、不可靠的服务，数据包可能会丢失、重复或乱序，可靠性由传输层（如 TCP）保证。

IPv4：32 位地址，资源已枯竭。
IPv6：128 位地址，号称“给地球上每一粒沙子分配一个 IP”。简化了头部，原生支持 IPSec，安全性更高。

13. ARP 协议的作用是什么？

将 IP 地址转换为 MAC 地址。通过局域网广播请求，目标主机单播回复。

六、应用层协议核心（HTTP / HTTPS / DNS）

14. HTTP 1.0、1.1、2.0、3.0 的主要区别是什么？

HTTP 是基于 TCP 的应用层协议，随着互联网的发展不断演进：

HTTP 1.0：默认短连接（每次请求都需建立 TCP 连接），存在队头阻塞问题。
HTTP 1.1：默认长连接（Keep-Alive），引入了管道化机制（但存在服务端的队头阻塞），增加了缓存控制（Cache-Control）、断点续传（Range 头部）等功能。
HTTP 2.0：
- 多路复用：一个 TCP 连接上可以并发交错发送多个请求/响应（彻底解决 HTTP 层的队头阻塞）。
- 二进制分帧：数据解析更高效。
- 头部压缩（HPACK）：减少传输体积。
- 服务端推送（Server Push）：服务端可以主动向客户端推送资源。
HTTP 3.0：
- 基于 QUIC 协议（底层为 UDP）：彻底解决了 TCP 级别的队头阻塞问题。
- 连接迁移：基于连接 ID 而非 IP+端口识别连接，切换网络（如 Wi-Fi 换到 4G）时连接不断开。

版本	连接方式	队头阻塞	主要特性
HTTP 1.0	短连接	存在	无管道化
HTTP 1.1	长连接	存在	管道化、缓存控制、断点续传
HTTP 2.0	长连接	解决	多路复用、二进制分帧、头部压缩、服务端推送
HTTP 3.0	基于 QUIC（UDP）	彻底解决	连接迁移

补充：对头阻塞问题的理解：HTTP 1.x 中，如果一个请求被阻塞了（如服务器处理慢），后续的请求即使已经到达服务器，也无法得到响应，因为它们都在同一个 TCP 连接上排队等待前一个请求完成。而 HTTP 2.0 和 HTTP 3.0 通过多路复用和基于 UDP 的 QUIC 协议，彻底解决了这个问题，使得每个请求都可以独立处理，不受其他请求的影响。

15. GET 和 POST 的区别？

特性	GET	POST
语义	获取资源（读取）	提交/修改资源（写入）
参数位置	放在 URL 中（?key=value）	放在 HTTP 报文的 Body（请求体）中
安全性	较低（参数暴露在 URL，可被浏览器历史记录保存）	相对较高（参数在 Body 中，但不加密仍可抓包）
长度限制	受限于浏览器和服务器对 URL 长度的限制	理论上无限制（受限于服务器配置）
幂等性	幂等（执行多次结果相同）	不幂等（执行多次可能会创建多个资源）
缓存	浏览器默认会缓存 GET 请求	浏览器默认不会缓存 POST 请求

补充：幂等性是指无论执行多少次，结果都是一样的。GET 请求通常用于获取数据，不会对服务器资源造成修改，因此是幂等的。而 POST 请求通常用于提交数据或修改资源，每次执行可能会创建新的资源或修改现有资源，因此不是幂等的。

16. HTTP 常见的状态码有哪些？

2xx (成功)：
- 200 OK：请求成功。
- 204 No Content：请求成功，但响应报文不包含实体的主体部分。
- 206 Partial Content：客户端进行了范围请求（断点续传），服务器成功执行。
3xx (重定向)：
- 301 Moved Permanently：永久重定向（资源换了新 URL）。
- 302 Found：临时重定向。
- 304 Not Modified：资源未修改，走协商缓存（非常重要，面试常考浏览器缓存机制）。
4xx (客户端错误)：
- 400 Bad Request：请求报文有语法错误。
- 401 Unauthorized：请求需要认证信息。
- 403 Forbidden：服务器拒绝访问（通常是权限不足）。
- 404 Not Found：找不到请求的资源。
5xx (服务器错误)：
- 500 Internal Server Error：服务器内部错误（代码抛异常了）。
- 502 Bad Gateway：网关或代理服务器收到无效响应（常见于 Nginx 转发给后端服务失败）。
- 504 Gateway Timeout：网关超时（后端服务处理太慢）。

17. HTTPS 的工作原理是什么？（详细描述 TLS/SSL 握手过程）

HTTPS = HTTP + SSL/TLS。它通过非对称加密协商密钥，再通过对称加密传输数据，并利用数字证书验证身份。

SSL/TLS (Secure Sockets Layer / Transport Layer Security)是安全套接字层协议，TLS 是 SSL 的升级版本，SSL 3.0 之后就没有继续发展了。

简化的 TLS 1.2 握手过程如下：

Client Hello：客户端向服务端发送自己支持的 TLS 版本、加密套件列表，以及一个客户端随机数 (Random1)。
Server Hello：服务端确认 TLS 版本和加密套件，发送一个服务端随机数 (Random2)，并把包含公钥的数字证书发送给客户端。
客户端验证证书：客户端确保证书是由权威 CA 签发的，域名一致且未过期。
生成 Pre-Master Secret：客户端生成一个新的随机数 Pre-Master Secret，用证书里的公钥进行加密，发送给服务端。
服务端解密：服务端用自己的私钥解密，得到 Pre-Master Secret。
生成最终对称密钥 (Master Secret)：此时双方都有了 Random1、Random2 和 Pre-Master Secret，双方使用相同的算法计算出最终的对称密钥（会话密钥）。
加密通信：后续的 HTTP 数据传输全部使用这个对称密钥进行加密和解密。

18. DNS 的解析过程是怎样的？为什么 DNS 既使用 TCP 又使用 UDP？

解析过程（浏览器输入域名后）：
1. 查浏览器缓存。
2. 查操作系统缓存（如 hosts 文件）。
3. 查本地 DNS 服务器（通常由 ISP 提供，这步是递归查询）。
4. 本地 DNS 服务器依次向根域名服务器 -> 顶级域名服务器 (.com) -> 权威域名服务器 发起迭代查询，最终获取 IP 并返回给客户端。

TCP 还是 UDP？
- 默认使用 UDP (端口 53)：因为一次 UDP 请求和响应就能完成，无连接、速度快、负载低。
- 使用 TCP 的场景：
  1. 当响应报文大小超过 512 字节时（为了防止 UDP 报文被截断）。
  2. DNS 服务器之间进行区域传送（主从 DNS 数据同步）时，因为需要传输大量数据，必须保证可靠性，所以使用 TCP。

七、综合场景题

19. 【经典终极必考题】在浏览器中输入 URL 到页面显示，经历了什么过程？

这是一个贯穿整个网络体系的题目，必须对答如流：

URL 解析：浏览器解析 URL，确定协议（HTTP/HTTPS）、域名、端口、路径。
DNS 域名解析：依次查找各级缓存及 DNS 服务器，最终得到目标 IP 地址。
建立 TCP 连接：浏览器与目标服务器发起 TCP 三次握手。
TLS 握手（如果是 HTTPS）：进行密钥协商，验证证书，建立加密通道。
发送 HTTP 请求：浏览器构建 HTTP 请求报文并发送。
服务器处理并响应：服务器接收请求，由 Web Server（如 Nginx, Tomcat）处理，返回 HTTP 响应报文。
浏览器渲染页面：解析 HTML/CSS，生成 DOM 树和 CSSOM 树，合并为渲染树，布局并绘制到屏幕上。
断开 TCP 连接：通过 TCP 四次挥手释放连接（若为 Keep-Alive 则暂时保持）。

Networking on Snow

A Deep Dive into Go's Standard Library net Package and TChannel Package

1. 包概述

2. 核心基础类型

2.1 IP 地址（IP 类型）

核心方法与示例

2.2 IP 网段（IPNet 类型）

核心方法与示例

2.3 传输层地址（TCPAddr/UDPAddr）

地址解析示例

2.4 地址处理工具函数

3. TCP 网络编程（面向连接可靠传输）

3.1 基础 TCP 服务端

3.2 基础 TCP 客户端

3.3 TCP 连接高级配置

3.3.1 禁用 Nagle 算法（SetNoDelay）

3.3.2 TCP 保活机制（SetKeepAlive）

3.3.3 连接半关闭

4. UDP 网络编程（无连接数据报传输）

4.1 基础 UDP 服务端

4.2 基础 UDP 客户端

4.3 实战：UDP 心跳检测

5. DNS 域名解析

5.1 基础域名解析

5.2 高级 DNS 记录查询

5.3 自定义 DNS 解析器

6. 错误处理与超时控制

6.1 网络错误类型（net.Error）

6.2 超时控制详解

1. 连接超时

2. 读写超时

7. 高级连接配置：Dialer

7.1 Dialer 核心配置

8. Unix 域套接字（本地进程间通信）

8.1 流式 Unix 域套接字（类似 TCP）

9. 原始 IP 与 ICMP：实现 Ping 工具

10. 网络接口与本机信息获取

获取本机所有非回环 IP

11. 其他常用工具示例

11.1 简单端口扫描

11.2 内存管道 Pipe

11.3 Go 1.26 新特性：Dialer 新方法

11.4 自定义 DNS 在 HTTP 客户端中的应用

12. 避坑指南

TCP/IP Protocol Stack Interview Questions (Continuously Updated)

一、 网络模型基础

1. 讲一下 OSI 七层模型、TCP/IP 四层模型和五层体系结构？

二、 TCP 与 UDP 基础

2. TCP 和 UDP 的区别是什么？

三、 TCP 连接管理（绝对重点）

3. 请详细画出/描述 TCP 的三次握手过程？

4. 为什么是三次握手？两次不行吗？四次不行吗？

5. 请详细画出/描述 TCP 的四次挥手过程？

6. 为什么挥手需要四次，而握手只需要三次？

7. 什么是 TIME_WAIT 状态？为什么需要等待 2MSL？

8. 为什么 TIME_WAIT 的时间是 2MSL？为什么不是 MSL 或者 3MSL？

9. TIME_WAIT 状态会导致什么问题？如何解决？

四、 TCP 可靠传输与控制

10. TCP 是如何保证可靠传输的？

11. 详细说说 TCP 的拥塞控制？

五、 网络层与其他核心协议

12. IP 协议是干什么的？IPv4 和 IPv6 的区别？

13. ARP 协议的作用是什么？

六、 应用层协议核心（HTTP / HTTPS / DNS）

14. HTTP 1.0、1.1、2.0、3.0 的主要区别是什么？

15. GET 和 POST 的区别？

16. HTTP 常见的状态码有哪些？

17. HTTPS 的工作原理是什么？（详细描述 TLS/SSL 握手过程）

18. DNS 的解析过程是怎样的？为什么 DNS 既使用 TCP 又使用 UDP？

七、 综合场景题

19. 【经典终极必考题】在浏览器中输入 URL 到页面显示，经历了什么过程？

2.1 IP 地址（`IP` 类型）

2.2 IP 网段（`IPNet` 类型）

3.3.1 禁用 Nagle 算法（`SetNoDelay`）

3.3.2 TCP 保活机制（`SetKeepAlive`）

6.1 网络错误类型（`net.Error`）

7. 高级连接配置：`Dialer`

一、网络模型基础

五、网络层与其他核心协议

六、应用层协议核心（HTTP / HTTPS / DNS）

七、综合场景题