Linux Networking & TCP/IP for Developers · 课时

TCP 与 UDP 基础

区分 TCP（可靠、面向连接）与 UDP（不可靠、无连接），并了解它们各自在应用中的适用场景

第 3 / 4 课12 个步骤

TCP 与 UDP 基础 是 CoddyKit 上的免费 Linux Networking & TCP/IP for Developers 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Linux Networking & TCP/IP for Developers 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Linux Networking & TCP/IP for Developers 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Meet TCP and UDP

When data travels across a network, it uses different rules or 'protocols'. At the Transport layer of the TCP/IP model, two main protocols handle how applications send and receive data: TCP and UDP.

They both move data, but they do it in fundamentally different ways, each suited for specific tasks.

TCP: The Reliable Partner

TCP stands for Transmission Control Protocol. Think of TCP as a very careful post office that guarantees your letter will arrive, in order, and without errors.

It's connection-oriented: A connection must be established before data is sent.
It's reliable: It guarantees delivery of data.
It ensures ordered data transfer and error checking.

TCP's Connection Handshake

Before TCP sends any application data, it performs a 'three-way handshake' to establish a connection:

SYN (Synchronize): Client asks to connect.
SYN-ACK (Synchronize-Acknowledge): Server acknowledges and agrees.
ACK (Acknowledge): Client acknowledges, and the connection is ready.

This handshake ensures both sides are ready to communicate reliably.

TCP: Guarantees Delivery

TCP uses several mechanisms to ensure reliability:

Acknowledgements (ACKs): The receiver sends ACKs for data received. If no ACK, the sender retransmits.
Sequence Numbers: Data packets are numbered to ensure they arrive in the correct order and to detect missing packets.
Flow Control: Prevents a fast sender from overwhelming a slow receiver.
Congestion Control: Manages network traffic to avoid overloading the network.

TCP Client: A Brief Look

This Python code snippet shows how a TCP client socket is created and attempts to connect. Notice the SOCK_STREAM type, which signifies TCP.

Run it to see the connection attempt!

import socket

# Create a TCP (Stream) socket
# AF_INET for IPv4, SOCK_STREAM for TCP
tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Attempt to connect to a server
# This establishes the 3-way handshake
server_address = ('localhost', 8080)
print(f"Attempting TCP connection to {server_address[0]}:{server_address[1]}...")

try:
    tcp_client_socket.connect(server_address)
    print("TCP connection established.")
    message = b"Hello TCP!"
    tcp_client_socket.sendall(message)
    print(f"Sent: '{message.decode()}'")
    # In a real app, you'd also receive a response here
except ConnectionRefusedError:
    print("Connection refused. No TCP server running at that address.")
except Exception as e:
    print(f"An error occurred: {e}")
finally:
    tcp_client_socket.close()
    print("TCP socket closed.")

UDP: The Fast Messenger

UDP stands for User Datagram Protocol. Unlike TCP, UDP is like sending a postcard: you send it, and you hope it arrives, but there's no guarantee or tracking.

It's connectionless: No connection is established before sending.
It's unreliable: No guarantees of delivery, order, or error-free transmission.
It prioritizes speed and low overhead over reliability.

UDP: No Handshake, No ACKs

The simplicity of UDP comes from its lack of features:

There's no three-way handshake to set up a connection.
There are no acknowledgements (ACKs) for received data.
There's no retransmission of lost packets.
There's no built-in flow or congestion control.

This means less overhead, making it much faster for certain applications.

UDP Client: A Brief Look

This Python code demonstrates a UDP client sending data. Notice the SOCK_DGRAM type, which indicates UDP. Because it's connectionless, it can send data directly.

Run it to see a UDP datagram being sent!

import socket

# Create a UDP (Datagram) socket
# AF_INET for IPv4, SOCK_DGRAM for UDP
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# UDP is connectionless.
# You can send data directly without establishing a connection.
target_address = ('localhost', 9090)
message = b"Hello UDP!"
print(f"UDP socket created.")
print(f"Sending '{message.decode()}' to {target_address[0]}:{target_address[1]}...")

# Send the data
udp_socket.sendto(message, target_address)

print("UDP datagram sent.")
udp_socket.close()
print("UDP socket closed.")

TCP vs. UDP: The Core Differences

Here's a quick comparison of the two:

Connection: TCP is connection-oriented; UDP is connectionless.
Reliability: TCP guarantees delivery; UDP offers best-effort delivery.
Order: TCP ensures ordered data; UDP does not.
Speed: UDP is generally faster due to less overhead; TCP is slower due to reliability mechanisms.
Overhead: TCP has higher overhead; UDP has lower overhead.

When to Use TCP or UDP?

Choosing between TCP and UDP depends on your application's needs:

Use TCP for: Web browsing (HTTP/HTTPS), Email (SMTP, IMAP, POP3), File Transfer (FTP), Secure Shell (SSH). When data integrity and order are critical.
Use UDP for: Online gaming, Video/Audio streaming, Voice over IP (VoIP), Domain Name System (DNS). When speed and low latency are more important than guaranteed delivery.

Quick Check: Protocol Choices

Based on what you've learned, which of the following statements correctly describe UDP?

在交互式课程中回答

Recap: TCP & UDP Essentials

You've explored the fundamental differences between TCP and UDP!

TCP is reliable, connection-oriented, and ensures data integrity and order, but with higher overhead.
UDP is fast, connectionless, and has low overhead, but offers no delivery guarantees.

Understanding these distinctions is crucial for designing and troubleshooting network applications. Next, you'll apply these concepts to real-world scenarios!

免费开始

用 AI 导师学习 Linux Networking & TCP/IP for Developers — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 12
课程: 48

免费开始学习查看完整课程

常见问题解答

「TCP 与 UDP 基础」课时是免费的吗？

是的 — 「TCP 与 UDP 基础」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Linux Networking & TCP/IP for Developers 课程的其余内容，请升级到 CoddyKit PRO。 Linux Networking & TCP/IP for Developers 课程共包含 4 节课。

「TCP 与 UDP 基础」这节课中我会学到什么？

区分 TCP（可靠、面向连接）与 UDP（不可靠、无连接），并了解它们各自在应用中的适用场景你通过在浏览器中直接运行的动手代码来练习 Linux Networking & TCP/IP for Developers，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Linux Networking & TCP/IP for Developers 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Linux Networking & TCP/IP for Developers 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「TCP 与 UDP 基础」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Linux Networking & TCP/IP for Developers 课中编写并运行代码吗？

能。每节 Linux Networking & TCP/IP for Developers 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Linux Networking & TCP/IP for Developers