TCP/IP 是互联网的基石，所有网络通信（网页浏览、聊天、文件传输）都基于这套协议族实现。很多开发者只知道 “TCP 可靠、UDP 不可靠”，却不清楚其底层传输逻辑、三次握手 / 四次挥手的本质，以及如何在代码中落地。

本文将从「协议分层、核心协议、通信流程、实战案例」四个维度，详细拆解 TCP/IP，结合代码示例让你不仅理解原理，更能落地应用。

---

一、TCP/IP 核心认知：什么是协议族？

1.1 定义

TCP/IP 不是单个协议，而是一套分层的网络通信协议集合，全称是 “传输控制协议 / 网际协议”（Transmission Control Protocol/Internet Protocol）。它定义了数据如何从一台设备传输到另一台设备，是互联网的 “通用语言”。

1.2 核心设计思想：分层模型

TCP/IP 采用四层模型（对比 OSI 七层模型，更贴合实际应用），每层负责不同的功能，上层依赖下层，下层为上层提供服务：

TCP/IP 四层模型	核心功能	典型协议	对应 OSI 层
应用层	面向用户，提供网络服务（如网页、邮件）	HTTP、HTTPS、FTP、DNS、SMTP	应用层 + 表示层 + 会话层
传输层	端到端的数据传输（主机间进程通信）	TCP、UDP	传输层
网际层（网络层）	跨网络的路由选择（主机间数据传输）	IP、ICMP、ARP	网络层
网络接口层	物理网络的数据传输（网卡、网线）	以太网、WiFi、PPP	数据链路层 + 物理层

分层优势：

• 解耦：每层只需关注自身功能，修改某层不影响其他层（比如 HTTP 升级为 HTTPS，传输层仍用 TCP）；
• 易扩展：新增协议只需适配对应层级，无需重构整个体系。

---

二、TCP/IP 核心协议详解

2.1 网际层核心：IP 协议

IP 协议是 TCP/IP 的 “骨架”，核心作用是给网络中的设备分配唯一地址（IP 地址），并将数据从源主机路由到目标主机。

核心特性：

1. 无连接：发送数据前无需建立连接，直接发送，不保证对方是否接收；
2. 不可靠：不保证数据一定送达，也不保证数据顺序，丢包、乱序是常态；
3. 面向无报文：每个数据包（IP 数据报）独立传输，彼此无关联；
4. IP 地址：标识网络中的主机，分为 IPv4（32 位，如 192.168.1.1）和 IPv6（128 位，如 2001:0db8:85a3:0000:0000:8a2e:0370:7334）。

核心缺陷：

• 只负责 “传数据”，不关心 “传没传到、传对没”，因此需要传输层的 TCP 协议补充可靠性。

2.2 传输层核心 1：TCP 协议（可靠传输）

TCP（传输控制协议）是面向连接、可靠的字节流协议，核心目标是保证数据从一端准确、有序、完整地传输到另一端。

核心特性：

1. 面向连接：通信前必须通过 “三次握手” 建立连接，通信后通过 “四次挥手” 关闭连接；
2. 可靠传输：通过 “序列号、确认应答、重传机制、流量控制、拥塞控制” 保证数据不丢、不重、不乱；
3. 面向字节流：把数据视为连续的字节序列，无报文边界；
4. 全双工通信：连接建立后，双方可同时收发数据；
5. 拥塞控制：避免发送方发送速度过快，导致网络拥塞。

TCP 可靠传输的核心机制：

机制	作用
序列号	给每个字节编号，保证数据有序；接收方通过序列号判断是否丢包、乱序
确认应答（ACK）	接收方收到数据后，回复 ACK 告诉发送方 “已收到”；发送方未收到 ACK 则重传
重传机制	超时重传（未收到 ACK 超时后重传）、快速重传（收到重复 ACK 立即重传）
流量控制	通过滑动窗口，控制发送方的发送速度，避免接收方处理不过来
拥塞控制	慢启动、拥塞避免、快速重传、快速恢复，适配网络拥塞状态

2.3 传输层核心 2：UDP 协议（高效传输）

UDP（用户数据报协议）是无连接、不可靠的报文协议，核心目标是高效传输，牺牲可靠性。

核心特性：

1. 无连接：无需建立连接，直接发送数据报，开销小、速度快；
2. 不可靠：不保证数据送达，不保证顺序，无重传、无确认；
3. 面向报文：每个 UDP 数据报独立，保留报文边界；
4. 支持广播 / 组播：可向多个设备发送数据（TCP 仅支持单播）；
5. 开销小：头部仅 8 字节（TCP 头部至少 20 字节），传输效率高。

TCP vs UDP 对比（面试高频）：

特性	TCP	UDP
连接性	面向连接（三次握手）	无连接
可靠性	可靠（不丢、不重、不乱）	不可靠（可能丢包、乱序）
传输方式	字节流	数据报
开销	大（头部 20+ 字节，握手 / 挥手开销）	小（头部 8 字节）
速度	慢（可靠性机制耗时）	快（无额外开销）
适用场景	文件传输、网页加载、邮件（需可靠）	视频直播、游戏、物联网（需高效）

2.4 应用层核心：HTTP 协议（基于 TCP）

HTTP（超文本传输协议）是应用层最常用的协议，基于 TCP 实现，用于浏览器与服务器的通信。

核心特性：

1. 基于 TCP：每次请求前先建立 TCP 连接（HTTP/1.1 支持长连接，复用连接）；
2. 无状态：服务器不保存客户端的状态（如登录信息），需通过 Cookie/Session 补充；
3. 明文传输：HTTP 数据未加密，易被窃听、篡改（HTTPS 基于 TLS/SSL 加密）；
4. 请求 - 响应模型：客户端发请求，服务器回响应，一问一答。

---

三、TCP 核心流程：三次握手与四次挥手（重中之重）

3.1 三次握手：建立可靠连接

TCP 通信前必须建立连接，三次握手的核心是确认双方的收发能力都正常。

握手流程（以客户端 → 服务器为例）：

每一步的意义：

1. 第一次握手：客户端 → 服务器，发送 SYN 报文；
   • 客户端：我要连接你，我的初始序列号是 x；
   • 服务器：知道客户端 “能发”，但不确定客户端 “能收”。
2. 第二次握手：服务器 → 客户端，发送 SYN+ACK 报文；
   • 服务器：确认收到你的请求（ACK=x+1），我也要连接你，我的初始序列号是 y；
   • 客户端：知道服务器 “能发、能收”，但服务器还不确定客户端 “能收”。
3. 第三次握手：客户端 → 服务器，发送 ACK 报文；
   • 客户端：确认收到你的连接请求（ACK=y+1）；
   • 服务器：知道客户端 “能发、能收”，连接正式建立。

💡 为什么需要三次握手？核心是防止 “失效的连接请求” 被服务器接收。比如客户端发送的 SYN 报文因网络延迟到达服务器，服务器回复 SYN+ACK 后，客户端已超时关闭，服务器会一直等待客户端的 ACK，浪费资源。三次握手能确保双方都确认连接有效。

3.2 四次挥手：关闭连接

TCP 连接是全双工的，关闭连接时需要双方分别关闭读写通道，因此需要四次挥手。

挥手流程（以客户端 → 服务器为例）：

每一步的意义：

1. 第一次挥手：客户端 → 服务器，发送 FIN 报文；
   • 客户端：我没有数据要发给你了，关闭我的写通道；
   • 服务器：知道客户端不再发数据，但服务器还能给客户端发数据。
2. 第二次挥手：服务器 → 客户端，发送 ACK 报文；
   • 服务器：确认收到你的关闭请求，你的写通道已关闭；
   • 客户端：进入 FIN_WAIT_2 状态，等待服务器的 FIN 报文。
3. 第三次挥手：服务器 → 客户端，发送 FIN 报文；
   • 服务器：我也没有数据要发给你了，关闭我的写通道；
   • 客户端：知道服务器不再发数据。
4. 第四次挥手：客户端 → 服务器，发送 ACK 报文；
   • 客户端：确认收到你的关闭请求，你的写通道已关闭；
   • 服务器：收到 ACK 后关闭连接；客户端等待 2MSL（最大报文生存时间）后关闭连接（防止最后一个 ACK 丢失）。

💡 为什么需要四次挥手？因为 TCP 是全双工通信，关闭连接时需要分别关闭 “客户端→服务器” 和 “服务器→客户端” 两个方向的通道。第二次挥手只是确认客户端的关闭请求，服务器可能还有数据要发，因此需要等服务器发完数据后，再发第三次挥手请求关闭自己的通道。

---

四、TCP/IP 实战：Java 代码实现 TCP 通信

4.1 核心 API

Java 提供 java.net 包实现 TCP 通信，核心类：

• ServerSocket：服务器端，监听端口，接收客户端连接；
• Socket：客户端 / 服务器端的通信套接字，封装了输入 / 输出流；
• InputStream/OutputStream：读写数据。

4.2 案例 1：TCP 服务器（接收客户端数据并回复）

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * TCP 服务器端：监听 8888 端口，接收客户端数据并回复
 */
public class TcpServer {
    public static void main(String[] args) {
        // 1. 创建 ServerSocket，绑定端口 8888
        try (ServerSocket serverSocket = new ServerSocket(8888)) {
            System.out.println("TCP 服务器已启动，监听端口 8888...");
            
            // 2. 阻塞等待客户端连接（accept() 方法）
            Socket clientSocket = serverSocket.accept();
            System.out.println("客户端 " + clientSocket.getInetAddress() + " 已连接");
            
            // 3. 获取输入流（读取客户端数据）、输出流（回复客户端）
            try (
                BufferedReader in = new BufferedReader(
                    new InputStreamReader(clientSocket.getInputStream())
                );
                PrintWriter out = new PrintWriter(
                    new OutputStreamWriter(clientSocket.getOutputStream()), true
                )
            ) {
                // 4. 读取客户端发送的消息
                String clientMsg = in.readLine();
                System.out.println("收到客户端消息：" + clientMsg);
                
                // 5. 回复客户端
                out.println("服务器已收到消息：" + clientMsg);
                
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 6. 关闭客户端连接
                clientSocket.close();
                System.out.println("客户端连接已关闭");
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.3 案例 2：TCP 客户端（发送数据给服务器并接收回复）

import java.io.*;
import java.net.Socket;

/**
 * TCP 客户端：连接服务器 127.0.0.1:8888，发送数据并接收回复
 */
public class TcpClient {
    public static void main(String[] args) {
        // 1. 创建 Socket，连接服务器（IP + 端口）
        try (Socket socket = new Socket("127.0.0.1", 8888)) {
            System.out.println("已连接到 TCP 服务器");
            
            // 2. 获取输出流（发送数据）、输入流（接收回复）
            try (
                PrintWriter out = new PrintWriter(
                    new OutputStreamWriter(socket.getOutputStream()), true
                );
                BufferedReader in = new BufferedReader(
                    new InputStreamReader(socket.getInputStream())
                )
            ) {
                // 3. 发送消息给服务器
                String sendMsg = "Hello TCP Server!";
                out.println(sendMsg);
                System.out.println("客户端发送消息：" + sendMsg);
                
                // 4. 接收服务器回复
                String serverMsg = in.readLine();
                System.out.println("收到服务器回复：" + serverMsg);
                
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.4 案例 3：UDP 通信（简单高效）

// UDP 服务器端
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpServer {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket(8888)) {
            System.out.println("UDP 服务器已启动，监听端口 8888...");
            
            // 接收数据的缓冲区
            byte[] buffer = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
            
            // 阻塞接收客户端数据
            socket.receive(receivePacket);
            String clientMsg = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("收到客户端消息：" + clientMsg);
            
            // 回复客户端
            String replyMsg = "服务器已收到：" + clientMsg;
            byte[] replyBytes = replyMsg.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(
                replyBytes, replyBytes.length,
                receivePacket.getAddress(), receivePacket.getPort()
            );
            socket.send(sendPacket);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// UDP 客户端
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpClient {
    public static void main(String[] args) {
        try (DatagramSocket socket = new DatagramSocket()) {
            // 发送数据给服务器
            String sendMsg = "Hello UDP Server!";
            byte[] sendBytes = sendMsg.getBytes();
            DatagramPacket sendPacket = new DatagramPacket(
                sendBytes, sendBytes.length,
                InetAddress.getByName("127.0.0.1"), 8888
            );
            socket.send(sendPacket);
            System.out.println("客户端发送消息：" + sendMsg);
            
            // 接收服务器回复
            byte[] buffer = new byte[1024];
            DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
            socket.receive(receivePacket);
            String serverMsg = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("收到服务器回复：" + serverMsg);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

---

五、TCP/IP 常见问题与面试考点

5.1 高频面试题

1. TCP 三次握手的目的是什么？为什么不是两次 / 四次？答：目的是确认双方的收发能力都正常，防止失效的连接请求浪费服务器资源。两次握手无法确认客户端的接收能力，四次握手则多余（三次已足够）。

2. TCP 四次挥手的原因？为什么关闭连接需要四次？答：TCP 是全双工通信，关闭连接需要分别关闭两个方向的读写通道。第二次挥手只是确认客户端的关闭请求，服务器可能还有数据要发，因此需要等服务器发完数据后，再发第三次挥手，最后客户端确认，共四次。

3. TCP 如何保证可靠传输？答：通过序列号（有序）、确认应答（确认收到）、重传机制（丢包重传）、流量控制（滑动窗口）、拥塞控制（适配网络）五大机制保证可靠。

4. TCP 和 UDP 的区别？分别适用什么场景？答：TCP 面向连接、可靠、速度慢，适合文件传输、网页加载等需可靠的场景；UDP 无连接、不可靠、速度快，适合视频直播、游戏、物联网等需高效的场景。

5. TCP 滑动窗口的作用？答：实现流量控制，让发送方的发送速度适配接收方的处理能力，避免接收方缓冲区溢出。

5.2 常见网络问题

1. 丢包怎么办？

   • TCP：超时重传 / 快速重传，保证数据最终送达；
   • UDP：无重传机制，需上层应用自己处理（如游戏中丢包则忽略，或重传关键帧）。

2. 粘包 / 拆包问题（TCP 字节流特性）原因：TCP 是字节流，无报文边界，发送方一次发 100 字节，接收方可能分两次收（50+50），或一次收 200 字节（粘包）。解决方案：

   • 固定长度：每个报文固定长度，不足补 0；
   • 分隔符：用特殊字符（如 \n）分隔报文；
   • 长度前缀：报文头部加长度字段，标识报文长度。

---

六、总结

TCP/IP 是网络通信的基础，核心要点可总结为：

1. 分层模型：四层结构（应用层、传输层、网际层、网络接口层），每层各司其职；
2. 核心协议：IP 负责路由，TCP 负责可靠传输，UDP 负责高效传输，HTTP 基于 TCP 实现应用层通信；
3. TCP 核心：三次握手建立连接，四次挥手关闭连接，通过五大机制保证可靠传输；
4. 实战落地：Java 中用 ServerSocket/Socket 实现 TCP 通信，DatagramSocket 实现 UDP 通信。

吃透 TCP/IP 不仅能理解网络通信的本质，更能在开发网络应用（如即时通讯、文件传输）时，快速定位问题、优化性能。