知识点编号：003
难度等级：⭐⭐（必须掌握）
面试频率：🔥🔥🔥🔥🔥（超高频！）
🎯 一句话总结
TCP就像打电话📞（可靠但墨迹），UDP就像喊话📢（快速但可能听不清）！
🤔 什么是TCP和UDP？
想象你要给朋友传递消息，有两种方式：
- 打电话（TCP）：先拨号，对方接通后才能说话，确保对方听到了每一句话。
- 大喊（UDP）：直接喊出去，不管对方听没听到，也不知道对方是否在。
📖 正经版定义
- TCP（Transmission Control Protocol）：传输控制协议，面向连接的、可靠的、基于字节流的传输层协议。
- UDP（User Datagram Protocol）：用户数据报协议，无连接的、不可靠的、基于数据报的传输层协议。
📊 核心区别对比表
| 特性 | TCP 🐌 | UDP 🚀 |
|---|---|---|
| 连接性 | 面向连接（需要三次握手） | 无连接（直接发送） |
| 可靠性 | 可靠传输（有确认、重传机制） | 不可靠传输（发了就不管） |
| 速度 | 慢（有各种机制开销） | 快（没有额外开销） |
| 顺序性 | 保证数据顺序 | 不保证数据顺序 |
| 数据边界 | 无数据边界（字节流） | 有数据边界（数据报） |
| 头部开销 | 20字节（更大） | 8字节（更小） |
| 拥塞控制 | 有 | 无 |
| 流量控制 | 有 | 无 |
| 应用场景 | 文件传输、网页浏览、邮件 | 视频直播、在线游戏、DNS查询 |
| 生活比喻 | 打电话 📞 | 喊话 📢 |
🎭 详细对比
1. 连接性 🔗
TCP：面向连接
必须先建立连接（三次握手）才能传输数据
客户端 服务器
| |
| SYN "嗨，能聊吗？" |
|------------------------->|
| |
| SYN+ACK "可以啊！" |
|<-------------------------|
| |
| ACK "好，开始吧！" |
|------------------------->|
| |
| "这是第1条消息" |
|------------------------->|
| "这是第2条消息" |
|------------------------->|
生活例子：
你想和朋友聊天，必须先打电话接通，听到"喂"，
确认对方在，才能开始说话。
UDP：无连接
不需要建立连接，直接发送数据
客户端 服务器
| |
| "这是第1条消息" |
|------------------------->|
| "这是第2条消息" |
|------------------------->|
| "这是第3条消息" |
|------------------------->|
（不管对方是否存在，直接发！）
生活例子：
你在教室里大喊"上课了！"，不管有没有人听到，
也不管谁听到了，反正喊出去就完事了。
2. 可靠性 ✅ vs ❌
TCP：可靠传输
机制1：确认应答（ACK）
发送方："我发了数据1"
接收方："收到数据1" ✅
发送方："好，我继续发数据2"
机制2：超时重传
发送方："我发了数据2"
接收方：（网络故障，没收到）
发送方：（等了一会儿，没收到ACK）
发送方："我再发一次数据2"
接收方："收到数据2" ✅
机制3：顺序控制
接收方收到：数据3、数据1、数据2（乱序）
接收方重新排序：数据1、数据2、数据3 ✅
交给应用层：正确的顺序
机制4：丢包重传
发送方："数据1、数据2、数据3、数据4"
接收方："收到1、2、4，但3丢了" ❌
发送方："好，我重发数据3"
接收方："收到3了" ✅
生活例子：
寄快递，有物流追踪，签收确认，
丢了会重发，保证一定送到。📦
UDP：不可靠传输
发送方："数据1"
发送方："数据2"
发送方："数据3"
接收方：（只收到数据1和3，数据2丢了）
发送方：（不知道丢了，继续发送）
- 没有确认机制 ❌
- 没有重传机制 ❌
- 不保证顺序 ❌
- 可能丢包 ❌
- 可能重复 ❌
生活例子：
发传单，扔出去就不管了，
掉地上还是被看了，都不知道。📄
3. 速度 🚀
TCP：相对慢
为什么慢？
1. 建立连接：三次握手（1.5 RTT）
2. 传输数据：
- 发送数据
- 等待ACK
- 收到ACK才能发下一批
3. 拥塞控制：网络拥塞时主动降速
4. 流量控制：接收方忙时主动降速
5. 关闭连接：四次挥手（2 RTT）
总开销 = 建立连接 + 确认延迟 + 控制开销 + 关闭连接
生活例子：
打电话
1. 拨号等接通（建立连接）
2. 说一句，等对方"嗯"（确认）
3. 对方说"慢点，我记不下来了"（流量控制）
4. 挂电话前说"拜拜"（关闭连接）
UDP：非常快
为什么快？
1. 无需建立连接：直接发！
2. 无需等待ACK：发完就不管！
3. 无拥塞控制：一直全速发！
4. 无流量控制：管你接不接得住！
5. 无需关闭连接：发完就完事！
总开销 ≈ 0
生活例子：
大喊一声
不用拨号，不用等回应，
张口就喊，喊完就走！
4. 数据边界 📦
TCP：无数据边界（字节流）
发送方：
send("Hello")
send("World")
接收方可能收到：
- "HelloWorld" (合并了！)
- "Hel" + "loWor" + "ld" (拆开了！)
- "H" + "e" + "l" + "l" + "o" + "W" + "o" + "r" + "l" + "d" (全拆了！)
TCP把数据看作连续的字节流，
不保留消息边界！
这就是"粘包"和"拆包"问题！
解决方案：
1. 固定长度
2. 特殊分隔符（如\n）
3. 在消息头部加长度字段
生活例子：
你说："我喜欢你"（3个字）
对方听到："我/喜欢/你"、"我喜/欢你"、"我喜欢你"
都有可能，需要自己断句！
UDP：有数据边界（数据报）
发送方：
send("Hello")
send("World")
接收方收到：
- "Hello" (一个数据报)
- "World" (另一个数据报)
或者：
- "World" (可能先到)
- "Hello" (可能后到)
或者：
- "Hello" (只收到这个)
- (World丢了)
但绝不会合并或拆分！
每个send()对应一个独立的数据报！
生活例子：
你发两条微信：
"我喜欢你"
"开玩笑的"
对方要么收到两条完整的消息，
要么丢一条，但不会合并成"我喜欢你开玩笑的"
5. 头部开销 📏
TCP头部：20字节（更大）
TCP头部结构（20-60字节）：
0 15 16 31
+----------------------+----------------------+
| 源端口 (16位) | 目标端口 (16位) |
+----------------------+----------------------+
| 序列号 (32位) |
+----------------------------------------------+
| 确认号 (32位) |
+------+-------+------+------------------------+
|头长度|保留位 |标志位| 窗口大小 (16位) |
+------+-------+------+------------------------+
| 校验和 (16位) | 紧急指针 (16位) |
+----------------------+----------------------+
| 选项 (可选，0-40字节) |
+----------------------------------------------+
必须字段：20字节
可选字段：最多40字节
包含：
- 源端口、目标端口（4字节）
- 序列号（4字节）
- 确认号（4字节）
- 标志位（SYN、ACK、FIN等）
- 窗口大小（流量控制）
- 校验和（错误检测）
- ... 等等
为了可靠性和控制，头部很大！
UDP头部：8字节（更小）
UDP头部结构（固定8字节）：
0 15 16 31
+----------------------+----------------------+
| 源端口 (16位) | 目标端口 (16位) |
+----------------------+----------------------+
| 长度 (16位) | 校验和 (16位) |
+----------------------+----------------------+
只有：
- 源端口、目标端口（4字节）
- 长度（2字节）
- 校验和（2字节）
就这么简单！头部固定8字节！
对比：
TCP头部：至少20字节
UDP头部：固定8字节
UDP比TCP节省 12字节！
如果发送1000字节数据：
TCP：1020字节（开销2%）
UDP：1008字节（开销0.8%）
如果发送100字节数据：
TCP：120字节（开销20%！）
UDP：108字节（开销8%）
短消息时，TCP开销比例很大！
🎮 使用场景对比
TCP适用场景 📞
✅ 适合TCP的场景
-
文件传输（FTP、HTTP下载）
- 必须完整传输 - 丢一点数据都不行 - 顺序必须正确 例子：下载一个ZIP文件 - 如果丢了1KB数据，整个文件损坏！ - 必须用TCP保证完整性 -
网页浏览（HTTP/HTTPS）
- HTML、CSS、JS必须完整 - 图片必须完整 - 顺序错误会导致显示错误 例子：加载一个网页 - HTML必须完整才能解析 - CSS样式丢失会导致页面难看 -
电子邮件（SMTP、POP3、IMAP）
- 邮件内容必须完整 - 不能丢失附件 - 顺序必须正确 例子：发送一封重要邮件 - 如果丢了"不"字，"不同意"变成"同意" - 后果很严重！😱 -
远程登录（SSH、Telnet）
- 命令必须完整 - 顺序必须正确 - 丢失会导致命令错误 例子：执行 rm -rf /tmp - 如果变成 rm -rf / - 服务器炸了！💥 -
数据库连接
- SQL语句必须完整 - 查询结果必须准确 - 事务必须可靠
❌ 不适合TCP的场景
-
实时性要求高的应用
- TCP的重传机制会导致延迟
- 例：视频直播（宁可丢帧，不要卡顿）
-
小数据传输
- TCP建立连接开销大
- 例：DNS查询（只需一问一答）
-
广播/组播
- TCP只能一对一
- 例：局域网广播
UDP适用场景 📢
✅ 适合UDP的场景
-
视频直播/视频通话
- 实时性要求高 - 丢几帧无所谓（人眼看不出） - 如果重传，画面会卡顿 例子：看直播 - 丢了1秒画面：稍微卡一下，继续看 - 用TCP重传那1秒：直播延迟越来越大！ 宁可丢帧，不要延迟！ -
在线游戏
- 延迟要求极高（<50ms） - 丢失一些数据包可以接受 - 例：你的位置更新 例子：玩FPS游戏 - 0.1秒前的位置丢了：没关系，用最新的位置 - 用TCP重传0.1秒前的数据：游戏卡成PPT！ 旧数据没用，只要最新的！ -
DNS查询
- 只需一问一答 - 建立TCP连接浪费时间 - 查询失败就重新查 例子：访问 www.baidu.com - UDP查询：发送1个包，收到1个包，完事！ - TCP查询：握手3个包，查询2个包，挥手4个包，共9个包！ UDP快多了！ -
语音通话（VoIP）
- 实时性要求高 - 丢一点声音可以接受 - 重传会导致回音和延迟 例子：打网络电话 - 丢了"嗯"：没关系，继续说 - 重传"嗯"：对方听到两个"嗯"，还有延迟 -
IPTV（网络电视）
- 多播/广播 - TCP只能一对一，无法多播 - UDP可以一对多 例子：1000人同时看一个频道 - UDP：服务器发一份数据，路由器复制给1000人 - TCP：服务器要分别发1000份数据！ -
物联网（IoT）
- 设备资源有限 - TCP状态机太复杂 - UDP简单，资源占用少 例子：温度传感器 - 每秒上报温度 - 丢一次没关系，下一秒还会发 -
流媒体传输
- 音乐、视频播放 - 实时性重要 - 丢一点可以接受（用算法补偿）
❌ 不适合UDP的场景
-
文件传输
- 必须保证完整性
- UDP会丢包
-
金融交易
- 不能丢失任何数据
- 必须可靠
-
数据库操作
- 必须保证数据准确
- 不能丢失
💻 Java代码示例
TCP客户端和服务器
// TCP服务器
import java.io.*;
import java.net.*;
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("📞 TCP服务器启动，等待连接...");
// 接受连接（三次握手）
Socket socket = serverSocket.accept();
System.out.println("✅ 客户端已连接");
// 读取数据（可靠接收）
BufferedReader reader = new BufferedReader(
new InputStreamReader(socket.getInputStream())
);
String message = reader.readLine();
System.out.println("📥 收到消息：" + message);
// 发送响应（可靠发送）
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
writer.println("服务器收到了：" + message);
socket.close();
serverSocket.close();
}
}
// TCP客户端
public class TCPClient {
public static void main(String[] args) throws IOException {
// 建立连接（三次握手）
Socket socket = new Socket("localhost", 8888);
System.out.println("✅ 连接成功");
// 发送数据（可靠发送）
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
writer.println("Hello from TCP!");
// 读取响应（可靠接收）
BufferedReader reader = new BufferedReader(
new InputStreamReader(socket.getInputStream())
);
String response = reader.readLine();
System.out.println("📥 服务器响应：" + response);
socket.close();
}
}
UDP发送方和接收方
// UDP接收方
import java.net.*;
public class UDPServer {
public static void main(String[] args) throws Exception {
// 创建UDP socket（无需建立连接！）
DatagramSocket socket = new DatagramSocket(9999);
System.out.println("📢 UDP服务器启动，等待数据...");
// 准备接收缓冲区
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
// 接收数据（可能丢包！）
socket.receive(packet); // 阻塞等待
String message = new String(packet.getData(), 0, packet.getLength());
System.out.println("📥 收到消息：" + message);
System.out.println("来自：" + packet.getAddress() + ":" + packet.getPort());
// 发送响应（可能丢包！）
String response = "服务器收到了！";
byte[] responseData = response.getBytes();
DatagramPacket responsePacket = new DatagramPacket(
responseData,
responseData.length,
packet.getAddress(),
packet.getPort()
);
socket.send(responsePacket);
socket.close();
}
}
// UDP发送方
public class UDPClient {
public static void main(String[] args) throws Exception {
// 创建UDP socket（无需建立连接！）
DatagramSocket socket = new DatagramSocket();
// 准备数据
String message = "Hello from UDP!";
byte[] data = message.getBytes();
// 指定目标地址和端口
InetAddress address = InetAddress.getByName("localhost");
DatagramPacket packet = new DatagramPacket(data, data.length, address, 9999);
// 发送数据（发了就不管了！）
socket.send(packet);
System.out.println("📤 数据已发送（不知道是否送达）");
// 等待响应（可能收不到！）
byte[] buffer = new byte[1024];
DatagramPacket responsePacket = new DatagramPacket(buffer, buffer.length);
// 设置超时（避免永远等待）
socket.setSoTimeout(5000); // 5秒超时
try {
socket.receive(responsePacket);
String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
System.out.println("📥 收到响应：" + response);
} catch (SocketTimeoutException e) {
System.out.println("❌ 超时，没收到响应（可能丢包了）");
}
socket.close();
}
}
TCP vs UDP 性能测试
import java.io.*;
import java.net.*;
import java.util.concurrent.*;
public class TCPvsUDPBenchmark {
// TCP性能测试
public static long testTCP(int messageCount) throws Exception {
long startTime = System.currentTimeMillis();
// 启动TCP服务器
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(() -> {
try {
ServerSocket serverSocket = new ServerSocket(8888);
Socket socket = serverSocket.accept();
DataInputStream dis = new DataInputStream(socket.getInputStream());
for (int i = 0; i < messageCount; i++) {
dis.readInt();
}
socket.close();
serverSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
});
Thread.sleep(100); // 等待服务器启动
// TCP客户端发送
Socket socket = new Socket("localhost", 8888);
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
for (int i = 0; i < messageCount; i++) {
dos.writeInt(i);
dos.flush();
}
socket.close();
executor.shutdown();
executor.awaitTermination(10, TimeUnit.SECONDS);
long endTime = System.currentTimeMillis();
return endTime - startTime;
}
// UDP性能测试
public static long testUDP(int messageCount) throws Exception {
long startTime = System.currentTimeMillis();
// 启动UDP接收方
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(() -> {
try {
DatagramSocket socket = new DatagramSocket(9999);
byte[] buffer = new byte[4];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
for (int i = 0; i < messageCount; i++) {
socket.receive(packet);
}
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
});
Thread.sleep(100); // 等待接收方启动
// UDP发送方
DatagramSocket socket = new DatagramSocket();
InetAddress address = InetAddress.getByName("localhost");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
for (int i = 0; i < messageCount; i++) {
baos.reset();
dos.writeInt(i);
byte[] data = baos.toByteArray();
DatagramPacket packet = new DatagramPacket(data, data.length, address, 9999);
socket.send(packet);
}
socket.close();
executor.shutdown();
executor.awaitTermination(10, TimeUnit.SECONDS);
long endTime = System.currentTimeMillis();
return endTime - startTime;
}
public static void main(String[] args) throws Exception {
int messageCount = 10000;
System.out.println("📊 开始性能测试（发送" + messageCount + "条消息）\n");
// 测试TCP
long tcpTime = testTCP(messageCount);
System.out.println("📞 TCP用时：" + tcpTime + "ms");
Thread.sleep(1000);
// 测试UDP
long udpTime = testUDP(messageCount);
System.out.println("📢 UDP用时：" + udpTime + "ms");
System.out.println("\n📈 结论：");
System.out.println("UDP比TCP快 " + (tcpTime - udpTime) + "ms");
System.out.println("UDP是TCP速度的 " + String.format("%.2f", (double)tcpTime / udpTime) + " 倍");
}
}
🐛 常见面试题
Q1：TCP和UDP最大的区别是什么？
答案：
最本质的区别：TCP面向连接且可靠，UDP无连接且不可靠。
具体体现：
- 连接性：TCP需要三次握手建立连接，UDP直接发送
- 可靠性：TCP有确认、重传、顺序保证，UDP没有
- 速度：UDP比TCP快，因为没有额外的可靠性机制
- 应用场景：TCP用于对数据完整性要求高的场景，UDP用于对实时性要求高的场景
生活类比：
- TCP像打电话：先拨号接通，对方确认收到每句话
- UDP像喊话：直接喊出去，不管对方听没听到
Q2：为什么视频直播用UDP而不用TCP？
答案：
核心原因：视频直播对实时性要求高，宁可丢帧也不要延迟。
详细分析：
假设网络丢了1秒的视频数据
使用UDP：
- 丢了1秒画面，稍微卡一下
- 继续播放最新的画面
- 延迟保持稳定
- 观众体验：稍微卡顿，但能继续看
使用TCP：
- 检测到丢包，触发重传
- 重传需要时间（可能100ms）
- 后续数据要等前面的数据到达
- 延迟累积越来越大
- 观众体验：画面越来越延迟，最后严重卡顿
结论：
- 视频直播是"实时"的，旧画面没有意义
- 丢几帧画面可以接受（人眼看不出）
- 但是延迟累积会让直播变成"录播"
- 所以用UDP，配合应用层的丢帧策略
补充：
- 现代视频传输协议（如RTP）基于UDP
- 但会在应用层实现部分可靠性机制
- 例如：FEC（前向纠错）、ARQ（自动重传请求）
- 平衡实时性和可靠性
Q3：什么时候用TCP，什么时候用UDP？如何选择？
答案：
选择TCP的场景：
- ✅ 数据不能丢失（文件传输、邮件、数据库）
- ✅ 顺序必须正确（网页加载、命令执行）
- ✅ 需要可靠性保证（金融交易、订单系统）
- ✅ 数据量大（大文件下载）
- ✅ 对延迟不敏感（可以等几百毫秒）
选择UDP的场景：
- ✅ 实时性要求高（视频直播、在线游戏）
- ✅ 可以容忍丢包（语音通话、IoT传感器）
- ✅ 小数据传输（DNS查询）
- ✅ 需要广播/组播（局域网广播、IPTV）
- ✅ 旧数据无用（只需要最新数据）
决策流程：
开始
|
├─ 数据不能丢失？
| └─ 是 → 用TCP
|
├─ 实时性要求高？
| └─ 是 → 用UDP
|
├─ 需要广播/组播？
| └─ 是 → 用UDP
|
├─ 小数据，简单请求？
| └─ 是 → 用UDP
|
└─ 默认 → 用TCP（更安全）
实际项目经验：
我在项目中的选择：
- Web应用（HTTP）：TCP ✓
- 数据库连接：TCP ✓
- 文件上传下载：TCP ✓
- 实时聊天（文字）：TCP ✓（WebSocket over TCP）
- 游戏位置同步：UDP ✓
- 视频会议：UDP ✓（WebRTC）
- 日志收集：UDP ✓（少量丢失可接受）
- DNS解析：UDP ✓（快速查询）
混合使用：
- 游戏：
* 位置、动作 → UDP（实时）
* 聊天、交易 → TCP（可靠）
- 视频会议：
* 音视频流 → UDP（实时）
* 信令、控制 → TCP（可靠）
Q4：UDP不可靠，怎么在UDP基础上实现可靠传输？
答案：
虽然UDP本身不可靠，但可以在应用层实现可靠性机制：
方案1：实现简单的可靠UDP
public class ReliableUDP {
private DatagramSocket socket;
private Map<Integer, DatagramPacket> sentPackets = new ConcurrentHashMap<>();
private AtomicInteger seqNum = new AtomicInteger(0);
// 发送数据（带序列号）
public void send(byte[] data, InetAddress address, int port) throws IOException {
int seq = seqNum.getAndIncrement();
// 添加序列号到数据包
ByteBuffer buffer = ByteBuffer.allocate(data.length + 4);
buffer.putInt(seq);
buffer.put(data);
byte[] packetData = buffer.array();
// 发送数据包
DatagramPacket packet = new DatagramPacket(packetData, packetData.length, address, port);
socket.send(packet);
// 保存已发送的数据包（用于重传）
sentPackets.put(seq, packet);
// 启动超时重传定时器
scheduleRetransmission(seq, packet);
}
// 接收ACK
public void receiveAck() {
// 接收方会发送ACK，包含序列号
// 收到ACK后，从sentPackets中移除
}
// 超时重传
private void scheduleRetransmission(int seq, DatagramPacket packet) {
// 如果超时没收到ACK，重传
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
if (sentPackets.containsKey(seq)) {
try {
socket.send(packet); // 重传
} catch (IOException e) {
e.printStackTrace();
}
}
}
}, 1000); // 1秒超时
}
}
方案2：使用成熟的协议
1. KCP协议
- 基于UDP的可靠传输协议
- 延迟比TCP低30%-40%
- 游戏行业常用
2. QUIC协议
- Google开发，HTTP/3基础
- 基于UDP，但实现了可靠传输
- 0-RTT连接建立
- 多路复用
- 现代浏览器已支持
3. UDT协议
- UDP-based Data Transfer
- 适合高速网络大数据传输
- 用于数据中心、CDN
4. 自定义应用层协议
- 序列号
- 确认应答
- 超时重传
- 窗口控制
方案3：在应用层实现部分可靠性
// 示例：重要数据用TCP，实时数据用UDP
public class HybridProtocol {
private Socket tcpSocket; // TCP连接
private DatagramSocket udpSocket; // UDP socket
// 发送重要数据（用TCP）
public void sendImportantData(byte[] data) throws IOException {
tcpSocket.getOutputStream().write(data);
}
// 发送实时数据（用UDP）
public void sendRealtimeData(byte[] data, InetAddress address, int port) throws IOException {
DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
udpSocket.send(packet);
}
}
// 使用场景：在线游戏
// - 玩家位置、动作 → UDP（实时性重要）
// - 聊天消息、交易 → TCP（可靠性重要）
🎓 知识点总结
⭐ 必须记住的要点
-
TCP vs UDP本质区别
- TCP：面向连接、可靠、慢、字节流
- UDP：无连接、不可靠、快、数据报
-
适用场景
- TCP：文件传输、网页浏览、数据库、邮件
- UDP：视频直播、游戏、DNS、VoIP
-
性能对比
- UDP更快（没有建立连接和确认的开销）
- TCP更可靠（有重传和顺序保证）
-
头部开销
- TCP：至少20字节
- UDP：固定8字节
📝 面试高分回答模板
面试官：请说说TCP和UDP的区别，以及各自的适用场景。
你的回答：
"TCP和UDP是传输层的两个核心协议，主要区别在于连接性和可靠性。
TCP是面向连接的可靠协议。它通过三次握手建立连接，提供确认、重传、
顺序保证等机制，确保数据可靠传输。但这些机制会带来额外的开销，
导致速度相对较慢。TCP适用于对数据完整性要求高的场景，如文件传输、
网页浏览、邮件、数据库连接等。
UDP是无连接的不可靠协议。它直接发送数据，没有确认和重传机制，
速度快、开销小（头部只有8字节）。但可能丢包、乱序、重复。UDP适用于
对实时性要求高、可以容忍部分数据丢失的场景，如视频直播、在线游戏、
语音通话、DNS查询等。
在实际项目中，我们常根据需求选择：
- 如果数据不能丢失，用TCP
- 如果实时性重要且可以容忍丢包，用UDP
- 有时会混合使用，重要数据用TCP，实时数据用UDP
例如在线游戏中，玩家的位置和动作用UDP传输（实时性重要），而聊天
消息和交易数据用TCP传输（可靠性重要）。"
💯 完美！面试官满意地点头~
🔗 相关知识点
- 上一个知识点：002-TCP四次挥手
- 下一个知识点：004-TCP流量控制机制
- 相关知识：Socket编程、网络性能优化、应用层协议
📚 推荐阅读
- 《图解TCP/IP》- TCP和UDP章节
- 《TCP/IP详解 卷1》- 第17章（TCP）、第11章（UDP）
- 《UNIX网络编程 卷1》- Socket编程
💪 加油！掌握了TCP和UDP的区别，你就能做出正确的协议选择！
记住：TCP像打电话（可靠但慢），UDP像喊话（快速但可能听不清）！📞📢
文档创建时间：2025-10-31
最后更新时间：2025-10-31
作者：AI助手 🤖
