Java网络编程实战：从Socket、TCP/UDP到高并发优化

1. 项目概述：从七层模型到Socket实战

搞Java开发，尤其是涉及到服务端或者中间件，网络编程这块是绕不过去的坎。很多朋友可能对HTTP、RESTful API用得很熟，但一提到底层的Socket、TCP/UDP协议，就觉得有点“黑盒”，出了问题也不知道从哪下手。我自己在早期做IM（即时通讯）项目时，就吃过这个亏，客户端连接时不时就莫名其妙断开，排查了半天才发现是TCP的Keep-Alive机制没处理好。所以，今天咱们就抛开那些框架的封装，直接深入到网络编程的基石——Socket套接字，以及它背后的TCP/UDP协议和网络模型。我会结合真实的代码示例和踩坑经验，把客户端和服务端的用法掰开揉碎了讲清楚。无论你是正在准备面试，被“三次握手四次挥手”困扰，还是在实际开发中遇到了“Address already in use”这类Socket错误，这篇文章都能给你一套清晰的解决思路和可直接运行的代码模板。

2. 网络基石：深入理解七层与四层模型

在动手写代码之前，我们必须先建立正确的网络世界观。很多人一上来就学Socket API，却不知道数据是怎么从你电脑上的一个Java程序，跑到千里之外另一台服务器的另一个程序里的。这个过程，就是由分层的网络模型来规范的。

2.1 经典OSI七层模型：一个理想化的蓝图

OSI（开放系统互联）七层模型是一个理论模型，它把复杂的网络通信过程划分成了七个层次，每一层都有明确的功能定义。虽然实际应用中（比如互联网）并没有完全按照它来，但它对于理解和教学来说，是无与伦比的工具。

1. 物理层：负责比特流在物理介质（如网线、光纤、无线电波）上的传输。关心的是电压高低、光脉冲有无、频率调制这些纯物理信号。Java程序员基本不直接接触这一层。
2. 数据链路层：负责在同一局域网内，通过物理地址（MAC地址）进行寻址和可靠传输。它将网络层传下来的数据包封装成“帧”，并处理帧的差错检测。典型的协议是以太网协议。ifconfig或ipconfig命令看到的信息，很多属于这一层。
3. 网络层：负责在不同网络之间进行寻址和路由，将数据包从源主机跨越多个网络节点送到目标主机。这一层的核心协议是IP协议，它定义了“IP地址”这个逻辑地址。我们常说的“ping”命令，用的就是网络层的ICMP协议。
4. 传输层：负责端到端的通信。所谓“端到端”，就是应用程序到应用程序。网络层只负责把数据包送到目标主机，但主机上可能运行着微信、浏览器、数据库等多个程序，传输层的作用就是通过端口号来区分这些程序。这一层是我们今天的主角，核心协议就是TCP和UDP。
5. 会话层：负责建立、管理和终止应用程序之间的会话。可以理解为一种“对话”的管理，比如在传输大文件时，如果网络中断，会话层协议可能支持从断点续传。在TCP/IP协议族中，这一层的功能很大程度上被整合到了传输层和应用层。
6. 表示层：负责数据的表示、加密、压缩。比如把Java对象序列化成JSON或二进制格式，或者进行SSL/TLS加密解密，可以认为是在这一层或应用层完成的。
7. 应用层：最接近用户的一层，为应用程序提供网络服务接口。我们日常开发的HTTP、FTP、SMTP（邮件）、WebSocket等协议都属于应用层协议。

注意：OSI模型是一个完美的理论框架，但现实中的互联网基石——TCP/IP协议族——并没有严格遵循它。TCP/IP更常用的是一个四层模型。

2.2 TCP/IP四层模型：互联网的现实骨架

TCP/IP模型更贴近互联网的实际实现，它被广泛地称为“互联网协议套件”。它把OSI的顶部三层（会话、表示、应用）合并成了一层。

1. 网络接口层：对应OSI的物理层和数据链路层。负责在本地网络媒介上传输数据帧。
2. 网际层：对应OSI的网络层。核心是IP协议，负责寻址和路由。
3. 传输层：与OSI的传输层完全对应。核心是TCP和UDP协议。
4. 应用层：对应OSI的会话层、表示层和应用层。所有基于TCP或UDP的高级协议都在这里，如HTTP、HTTPS、FTP、DNS、SMTP等。

为什么Java程序员要关心这个？因为当你创建一个Socket时，你本质上是在告诉操作系统：“我要在传输层（用TCP或UDP）建立一个通道”。而java.net包下的类，就是对操作系统底层Socket API的封装。理解分层，能让你在遇到“网络不通”时，有清晰的排查思路：是应用层代码写错了？还是传输层端口被占用了？或者是网络层的IP路由出了问题？

2.3 核心协议对比：TCP vs UDP

这是面试必问，也是实际选型的依据。光背“面向连接”和“无连接”是不够的，关键要理解它们带来的实际影响。

一个生活化的类比：

• TCP就像打电话：你先拨号（三次握手），对方接听，确认通信链路畅通后才开始说话。你会说“你听到了吗？”来确认（ACK），如果没听清你会要求对方重复（重传）。结束后要说“再见”才挂断（四次挥手）。
• UDP就像发短信或广播：你编辑好内容直接发送，不关心对方手机是否开机（是否在线），也不确认对方是否收到。你可能连续发好几条，但对方接收的顺序可能和你发送的顺序不一致。

实操心得： 选择TCP还是UDP，不是一个单纯的技术问题，而是一个业务权衡问题。我做过一个物联网数据采集项目，传感器数据上报频率很高，但丢一两个数据点对整体趋势分析影响不大。最初用了TCP，结果在弱网络环境下，频繁的重连和重传导致数据堆积和延迟飙升。后来切换到UDP，并在应用层实现了简单的丢包统计和心跳机制，系统吞吐量和实时性立刻得到了质的提升。所以，不要迷信TCP的可靠，在适合的场景下，UDP的“不可靠”恰恰是它的优势。

3. Socket编程核心：套接字详解

Socket（套接字）是网络编程的抽象概念，它是应用层与传输层之间的接口。你可以把它想象成网络世界里的“电话插座”。程序通过创建一个Socket，并绑定到一个IP地址和端口号（就像给电话机分配一个电话号码），就可以通过网络与其他程序“通话”了。

在Java中，java.net包提供了丰富的类来支持Socket编程，主要分为针对TCP的和针对UDP的两大类。

3.1 Socket与ServerSocket：TCP的左右手

对于TCP这种面向连接的协议，通信双方的角色是不对等的，分为服务端和客户端。

• ServerSocket： 服务端使用的“监听插座”。它绑定到一个特定的端口，并监听来自客户端的连接请求。它本身不用于数据传输，只负责“接电话”。
• Socket： 客户端和服务端都使用它来进行实际的数据传输。对于客户端，它是主动发起连接的“电话”；对于服务端，它是ServerSocket.accept()方法返回的、与特定客户端通信的“电话听筒”。

关键API解析：

1. 服务端创建：ServerSocket serverSocket = new ServerSocket(8080);这行代码创建了一个监听在8080端口的ServerSocket。
2. 监听连接：Socket clientSocket = serverSocket.accept();这是一个阻塞方法。调用后，程序会停在这里，直到有一个客户端尝试连接（“电话响了”）。一旦连接建立，它就返回一个新的Socket对象，代表与这个客户端的专用连接通道。
3. 客户端连接：Socket socket = new Socket("127.0.0.1", 8080);客户端通过这行代码，尝试连接到IP为127.0.0.1、端口为8080的服务端。
4. 获取流：连接建立后，双方通过Socket的输入输出流进行通信。
   • InputStream is = socket.getInputStream();用于读取对方发送来的数据。
   • OutputStream os = socket.getOutputStream();用于向对方发送数据。 通常我们会用BufferedReader/PrintWriter或DataInputStream/DataOutputStream等包装类来更方便地处理文本或二进制数据。

3.2 DatagramSocket与DatagramPacket：UDP的信使

UDP编程模型比TCP简单，因为它不需要连接。双方更像是在通过“邮差”发送明信片。

• DatagramSocket： 类似于邮局或邮箱。它绑定到一个端口，负责发送和接收数据包。无论是客户端还是服务端，都使用这个类。
• DatagramPacket： 就是“明信片”本身。它是一个容器，里面封装了要发送的数据、数据长度、目标地址（IP和端口）或源地址。

关键API解析：

1. 创建Socket：DatagramSocket socket = new DatagramSocket(8888);创建一个绑定到8888端口的UDP Socket（服务端通常需要绑定固定端口）。客户端可以不指定端口，系统会分配一个随机的。
2. 准备数据包：
   • 发送包：DatagramPacket sendPacket = new DatagramPacket(data, data.length, InetAddress.getByName("host"), port);
   • 接收包：先准备一个空缓冲区byte[] buffer = new byte[1024];，然后创建包DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length);
3. 发送与接收：
   • socket.send(sendPacket);
   • socket.receive(receivePacket);// 这也是一个阻塞方法，直到收到数据包。

注意事项：

• 数据边界：UDP的receive方法一次接收一个完整的DatagramPacket。如果发送方一次发送了100字节，接收方缓冲区即使有1024字节，也只会收到100字节，剩下的空间是空的。这完美体现了“面向数据报”的边界特性。
• MTU限制：一个UDP数据包的最大有效载荷通常受限于网络的MTU（最大传输单元，通常约1500字节）。如果发送的数据超过这个限制，IP层会进行分片，这会大大增加丢包风险。最佳实践是，在应用层控制UDP包的大小，建议在1400字节以内。
• 端口占用错误：如果你在启动服务时遇到java.net.BindException: Address already in use (Bind failed)，这通常意味着你指定的端口已被其他进程占用。可以用netstat -ano | findstr :端口号（Windows）或lsof -i:端口号（Linux/Mac）来查找并结束占用进程。

4. TCP协议客户端与服务端实战

理论说再多，不如跑一遍代码。我们来分别实现一个简单的TCP回显服务器和客户端。所谓“回显”，就是客户端发送什么，服务器就原样返回什么。

4.1 TCP服务端实现：多线程版本

一个简单的单线程服务器只能同时处理一个客户端，这显然不实用。下面是一个多线程版本，可以并发处理多个客户端连接。

import java.io.*; import java.net.*; import java.util.concurrent.*; public class TcpEchoServer { private static final int PORT = 8888; // 使用线程池来管理客户端处理线程 private static final ExecutorService executor = Executors.newCachedThreadPool(); public static void main(String[] args) { try (ServerSocket serverSocket = new ServerSocket(PORT)) { System.out.println("TCP回显服务器启动，监听端口：" + PORT); // 使用try-with-resources确保ServerSocket正确关闭 while (true) { // 无限循环，持续接受新连接 // 1. 等待客户端连接（阻塞） Socket clientSocket = serverSocket.accept(); System.out.println("客户端连接来自: " + clientSocket.getRemoteSocketAddress()); // 2. 将新连接交给线程池处理 executor.submit(new ClientHandler(clientSocket)); } } catch (IOException e) { e.printStackTrace(); } finally { executor.shutdown(); // 程序退出时关闭线程池 } } // 处理单个客户端连接的线程任务 static class ClientHandler implements Runnable { private final Socket socket; public ClientHandler(Socket socket) { this.socket = socket; } @Override public void run() { // 获取客户端的地址信息，用于日志 String clientAddress = socket.getRemoteSocketAddress().toString(); // 使用try-with-resources确保流和Socket正确关闭 try (BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) { // autoFlush设为true String inputLine; // 3. 循环读取客户端发送的数据 while ((inputLine = in.readLine()) != null) { // readLine()也是阻塞的 System.out.println("收到来自" + clientAddress + "的消息: " + inputLine); // 4. 回显数据给客户端 out.println("Echo: " + inputLine); // 简单的退出命令 if ("bye".equalsIgnoreCase(inputLine.trim())) { out.println("连接即将关闭。"); break; } } System.out.println("客户端 " + clientAddress + " 断开连接。"); } catch (IOException e) { System.err.println("处理客户端 " + clientAddress + " 时发生IO错误: " + e.getMessage()); } finally { try { socket.close(); // 确保Socket关闭 } catch (IOException e) { // 忽略关闭时的异常 } } } } }

代码关键点解析：

1. ServerSocket.accept()： 这是服务端的核心，它是一个阻塞调用。程序会在这里等待，直到有客户端连接进来。这通常运行在一个独立的、循环的线程中（如主线程）。
2. 线程池的使用： 直接为每个连接创建新线程（new Thread()）在连接数高时会导致资源耗尽。使用ThreadPoolExecutor（这里用Executors.newCachedThreadPool()简便创建）可以复用线程，管理并发。
3. try-with-resources： 从Java 7开始，强烈推荐使用此语法管理Socket、InputStream、OutputStream等资源，它能确保在代码块结束时自动调用close()方法，避免资源泄漏。
4. 流的包装：BufferedReader和PrintWriter包装了底层的字节流，让我们可以方便地按行（readLine和println）处理文本数据。注意PrintWriter的第二个参数autoFlush设为true，这样每次println后会自动刷新缓冲区，确保数据立即发送。
5. 连接关闭： 当客户端关闭连接，in.readLine()会返回null，这是退出读取循环的信号。服务端随后也应关闭Socket。

4.2 TCP客户端实现

客户端相对简单，主要任务是连接服务器，发送数据，并接收回复。

import java.io.*; import java.net.*; public class TcpEchoClient { private static final String SERVER_HOST = "localhost"; private static final int SERVER_PORT = 8888; public static void main(String[] args) { System.out.println("连接到服务器 " + SERVER_HOST + ":" + SERVER_PORT); // 使用try-with-resources自动管理Socket和流 try (Socket socket = new Socket(SERVER_HOST, SERVER_PORT); // 用于从控制台读取用户输入 BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in)); // 用于接收服务器消息 BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 用于向服务器发送消息 PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) { System.out.println("连接成功！输入消息发送给服务器，输入 'bye' 退出。"); String userInput; // 循环读取控制台输入 while ((userInput = stdIn.readLine()) != null) { // 1. 发送消息到服务器 out.println(userInput); // 如果用户输入bye，则跳出循环 if ("bye".equalsIgnoreCase(userInput.trim())) { break; } // 2. 等待并打印服务器回显 String serverResponse = in.readLine(); if (serverResponse != null) { System.out.println("服务器回复: " + serverResponse); } else { System.out.println("服务器无响应，连接可能已关闭。"); break; } } System.out.println("客户端退出。"); } catch (UnknownHostException e) { System.err.println("无法找到主机: " + SERVER_HOST); } catch (IOException e) { System.err.println("连接或IO错误: " + e.getMessage()); } } }

操作流程：

1. 先启动TcpEchoServer，你会看到“TCP回显服务器启动，监听端口：8888”。
2. 再启动一个或多个TcpEchoClient。服务端会打印“客户端连接来自...”。
3. 在客户端控制台输入任意文字，回车发送。
4. 服务端会收到并打印消息，然后回显给客户端。
5. 客户端收到回显并打印。
6. 输入“bye”并回车，客户端会断开连接，服务端对应的线程也会结束。

实操心得：处理Socket连接关闭在实际项目中，连接的管理比这个例子复杂得多。客户端可能异常崩溃（如进程被杀死），网络可能突然中断。服务端的readLine()可能一直阻塞，因为TCP连接在物理断开后，如果没有正确的关闭序列（如发送FIN包），服务端可能无法立即感知。一个健壮的服务端应该：

• 设置Socket的读写超时：socket.setSoTimeout(5000);// 5秒超时
• 实现心跳机制：客户端定期发送一个特定的小数据包（如ping），服务端定期检查。如果超过一定时间没收到心跳，则认为连接已失效，主动关闭。
• 使用NIO（java.nio.channels）而不是阻塞IO，可以更好地管理大量并发连接。

5. UDP协议客户端与服务端实战

UDP的编程模型更简单，但由于其无连接的特性，代码逻辑需要自己处理更多细节，比如数据包的完整性、顺序等。

5.1 UDP服务端实现

UDP服务端不需要accept，它只需要创建一个绑定到端口的DatagramSocket，然后等待数据包到来。

import java.net.*; public class UdpEchoServer { private static final int PORT = 9999; // 设置数据包最大大小 private static final int BUFFER_SIZE = 1024; public static void main(String[] args) { // 创建DatagramSocket并绑定到指定端口 try (DatagramSocket socket = new DatagramSocket(PORT)) { System.out.println("UDP回显服务器启动，监听端口：" + PORT); byte[] buffer = new byte[BUFFER_SIZE]; while (true) { // 无限循环处理数据包 // 1. 准备一个空包用于接收数据 DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length); // 2. 接收数据（阻塞，直到有数据包到达） socket.receive(receivePacket); // 3. 解析收到的数据 String receivedMsg = new String(receivePacket.getData(), 0, receivePacket.getLength(), "UTF-8"); InetAddress clientAddress = receivePacket.getAddress(); int clientPort = receivePacket.getPort(); System.out.println("收到来自 " + clientAddress.getHostAddress() + ":" + clientPort + " 的消息: " + receivedMsg); // 4. 准备回显数据 String echoMsg = "UDP Echo: " + receivedMsg; byte[] sendData = echoMsg.getBytes("UTF-8"); DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, clientAddress, clientPort); // 5. 发送回显数据包 socket.send(sendPacket); System.out.println("已向 " + clientAddress.getHostAddress() + ":" + clientPort + " 发送回显。"); } } catch (Exception e) { e.printStackTrace(); } } }

5.2 UDP客户端实现

UDP客户端同样使用DatagramSocket，它不需要“连接”，直接向服务器的地址和端口发送数据包即可。

import java.net.*; import java.util.Scanner; public class UdpEchoClient { private static final String SERVER_HOST = "localhost"; private static final int SERVER_PORT = 9999; private static final int BUFFER_SIZE = 1024; private static final int TIMEOUT_MS = 5000; // 设置接收超时5秒 public static void main(String[] args) { // 客户端Socket通常不需要绑定特定端口，系统会自动分配 try (DatagramSocket socket = new DatagramSocket()) { socket.setSoTimeout(TIMEOUT_MS); // 设置接收超时，避免无限等待 InetAddress serverAddress = InetAddress.getByName(SERVER_HOST); Scanner scanner = new Scanner(System.in); System.out.println("UDP客户端已启动。输入消息发送给服务器，输入 'bye' 退出。"); while (true) { System.out.print("请输入: "); String userInput = scanner.nextLine(); if (userInput == null || userInput.isEmpty()) { continue; } // 1. 发送数据包 byte[] sendData = userInput.getBytes("UTF-8"); DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, SERVER_PORT); socket.send(sendPacket); System.out.println("消息已发送。"); if ("bye".equalsIgnoreCase(userInput.trim())) { System.out.println("客户端退出。"); break; } // 2. 等待接收回显 byte[] buffer = new byte[BUFFER_SIZE]; DatagramPacket receivePacket = new DatagramPacket(buffer, buffer.length); try { socket.receive(receivePacket); String echoedMsg = new String(receivePacket.getData(), 0, receivePacket.getLength(), "UTF-8"); System.out.println("收到服务器回显: " + echoedMsg); } catch (SocketTimeoutException e) { System.out.println("接收超时，服务器可能未响应或数据包丢失。"); } } scanner.close(); } catch (Exception e) { e.printStackTrace(); } } }

UDP实战要点：

1. 无连接：客户端send时指定目标地址，服务端receive后从数据包中获取源地址用于回复。双方没有长期的连接状态。
2. 数据包边界：receive方法一次接收一个完整的DatagramPacket。如果发送方一次发送了“HelloWorld”，接收方不会分两次收到“Hello”和“World”。
3. 超时设置：socket.setSoTimeout(TIMEOUT_MS);对于UDP客户端至关重要。因为UDP不保证送达，如果服务器没收到包或者回显包丢失了，客户端receive会永远阻塞。设置超时可以避免程序“假死”。
4. 编码一致性：使用getBytes(“UTF-8”)和new String(..., “UTF-8”)确保发送和接收时字符编码一致，避免乱码。

6. 常见问题、排查技巧与性能优化

网络编程中遇到的问题千奇百怪，但很多都有共同的模式和解决方案。下面是我在多年开发中总结的一些典型问题及排查思路。

6.1 连接与端口相关问题

问题1：java.net.BindException: Address already in use这是最经典的错误，意味着你试图绑定的端口已被占用。

• 排查：
  1. 确认自己的程序是否未完全退出：尤其是开发时，可能之前的进程还在后台运行。在IDE中彻底停止程序，或通过任务管理器/ps命令查找并结束相关Java进程。
  2. 查找占用端口的进程：
     • Windows:netstat -ano | findstr :端口号，找到PID后，在任务管理器中结束进程。
     • Linux/Mac:lsof -i:端口号或netstat -tulnp | grep 端口号，找到PID后使用kill -9 PID结束。
  3. 检查是否有其他服务：比如MySQL默认用3306，Redis用6379，你的程序可能无意中用了这些知名端口。
  4. 使用SO_REUSEADDR选项：在创建ServerSocket之前，可以设置重用地址。这对于开发调试或需要快速重启服务时很有用。

     ServerSocket serverSocket = new ServerSocket(); serverSocket.setReuseAddress(true); // 必须在bind之前设置 serverSocket.bind(new InetSocketAddress(PORT));

问题2：java.net.ConnectException: Connection refused客户端连接时出现，意味着在指定的IP和端口上没有找到正在监听的服务。

• 排查：
  1. 确认服务端程序是否已启动。
  2. 确认IP和端口是否正确。localhost和127.0.0.1通常指向本机，但如果服务端绑定的是0.0.0.0（所有网卡）或特定IP，客户端需要对应修改。
  3. 检查防火墙：服务器防火墙可能阻止了该端口的入站连接。需要添加规则允许该端口（如Linux的iptables或firewalld，Windows的防火墙高级设置）。
  4. 服务端ServerSocket绑定地址：确保服务端绑定的是客户端能访问到的地址。new ServerSocket(port)默认绑定0.0.0.0（所有接口）。如果绑定的是127.0.0.1，则只有本机可以连接。

6.2 数据传输与流处理问题

问题3：readLine()阻塞或读不到完整数据

• 原因分析：readLine()依赖于换行符（\n或\r\n）来判断一行结束。如果对端发送的数据没有换行符，或者发送的数据量超过了缓冲区大小但还未遇到换行符，readLine()就会一直等待。
• 解决方案：
  1. 定义应用层协议：这是最根本的解决方法。例如，约定每个消息以换行符结尾（如本例），或者在每个消息前加上固定长度的消息头，指明后面消息体的长度。
  2. 使用DataInputStream.readFully(byte[])：如果你知道要读取的确切字节数，这个方法会一直阻塞直到读满指定的字节数组。
  3. 使用长度前缀法：发送方先发送一个4字节的整数（表示后续数据长度），接收方先读取这4字节，得到长度N，再精确读取N个字节。这是处理二进制数据的常用方法。

问题4：TCP粘包/拆包问题这不是Bug，而是TCP“字节流”特性导致的必然现象。发送方连续发送“Hello”和“World”两个包，接收方可能一次收到“HelloWorld”（粘包），也可能分两次收到“Hel”、“loWorld”（拆包）。

• 解决方案：与应用层协议设计紧密相关。
  1. 固定长度：每个消息都是固定长度，不足补位。简单但浪费空间。
  2. 分隔符：用特殊字符（如换行符）作为消息边界。简单，但分隔符本身不能出现在消息内容中，需要对内容转义。
  3. 长度字段：如上文所述，在消息头中定义长度字段。这是最常用、最灵活的方式。Netty等网络框架对此有很好的内置支持。

6.3 资源管理与性能优化

问题5：内存泄漏与文件描述符耗尽每个Socket连接在操作系统层面都对应一个文件描述符。如果连接关闭后，Java程序没有正确调用close()方法释放资源，就会导致“文件描述符耗尽”，新的连接无法建立，报错“Too many open files”。

• 最佳实践：
  1. 无条件使用try-with-resources：这是Java 7以后最好的资源管理方式，能确保在任何情况下（包括异常）资源都被关闭。
  2. 在finally块中显式关闭：如果不能用try-with-resources，必须在finally块中检查并关闭Socket和流。
  3. 检查关闭顺序：通常先关闭最外层的包装流（如BufferedReader），它们会负责关闭内层的流和Socket。但最稳妥的是在finally里分别尝试关闭。

     finally { try { if (out != null) out.close(); } catch (Exception e) {} try { if (in != null) in.close(); } catch (Exception e) {} try { if (socket != null && !socket.isClosed()) socket.close(); } catch (Exception e) {} }

问题6：应对高并发连接上面的多线程服务器模型（一个连接一个线程）在连接数达到几千时，线程上下文切换的开销会变得巨大，性能急剧下降。

• 优化方向：
  1. 使用NIO（Non-blocking I/O）：Java NIO提供了Selector和Channel，允许单个线程管理多个连接。只有当Channel准备好读写时，线程才会去处理，极大提高了线程利用率。这是构建高性能网络服务器（如Netty、Tomcat的NIO Connector）的基础。
  2. 使用成熟的网络框架：直接使用原生NIO API非常复杂。Netty是业界事实标准的异步事件驱动网络框架，它封装了NIO的复杂性，提供了优雅的API和强大的性能，是开发高性能网络应用的首选。
  3. 调整TCP参数：对于长连接服务，可以调整一些TCP栈参数，如SO_KEEPALIVE、TCP_NODELAY（禁用Nagle算法，减少小数据包的延迟）、接收和发送缓冲区大小等，以适应特定的业务场景。

网络编程是Java后端工程师的必备技能，理解Socket、TCP/UDP以及背后的网络模型，不仅能帮你写出更稳定的代码，更能让你在出现网络问题时，有章法地快速定位和解决。从简单的回显服务器起步，逐步深入到连接管理、协议设计、性能优化，这条路没有捷径，多写、多调、多思考，自然就能融会贯通。我个人的经验是，初期可以多用手工模拟各种异常情况（比如拔网线、强制杀死客户端进程），观察程序的表现，这对理解TCP/UDP的行为差异非常有帮助。当你对这块足够熟悉后，再去学习像Netty这样的框架，就会知其然也知其所以然，用起来也更加得心应手。