第 3 课：服务端优化

目标

本课的目标是通过使用自定义线程池来优化服务端，处理多个客户端连接请求，同时对可能出现的异常情况进行有效处理。我们将深入讲解如何使用线程池来管理连接，并解决常见的异常处理问题。

内容大纲

自定义线程池
- 介绍线程池的基本概念和为何在服务端使用线程池。
- 如何创建和配置自定义线程池来优化服务端处理多个客户端连接的效率。
异常处理
- 讲解在服务端开发中常见的异常情况以及如何进行异常捕获和处理。
- 包括网络异常、I/O异常等，确保服务端稳定运行。

自定义线程池

在前面的课程中，我们使用了简单的多线程模型来为每个客户端创建一个独立的线程。虽然这种方式能够实现并发处理，但随着客户端数量的增加，创建大量线程会消耗大量资源，甚至可能导致系统性能下降。为了优化这一问题，我们可以使用线程池。

线程池是一个可以复用线程的技术，线程池中的线程可以重复使用来处理不同的任务，而不是每次都创建新的线程。这样可以减少线程创建和销毁的开销，提高服务端的性能。

在 Java 中，我们可以通过 ExecutorService 接口来创建和管理线程池。ExecutorService 提供了多种线程池的实现方式，如 FixedThreadPool 和 CachedThreadPool，其中 FixedThreadPool 是一个固定大小的线程池，适合于我们这种对线程数量有限制的场景。

代码示例：

import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class Server {
    // 创建线程池，最多同时处理 10 个客户端连接
    private static final ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        try {
            // 创建 ServerSocket，监听端口 8080
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("服务端已启动，等待客户端连接...");

            while (true) {
                // 等待并接受客户端的连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("有客户端连接，准备处理...");

                // 使用线程池处理客户端连接
                executorService.submit(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            System.err.println("服务端出现异常: " + e.getMessage());
        }
    }
}

// 处理客户端请求的线程类
class ClientHandler implements Runnable {
    private Socket clientSocket;

    public ClientHandler(Socket socket) {
        this.clientSocket = socket;
    }

    @Override
    public void run() {
        try {
            // 获取客户端输入流，读取数据
            BufferedReader input = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            String message;
            while ((message = input.readLine()) != null) {
                System.out.println("客户端发送消息: " + message);
            }
        } catch (IOException e) {
            System.err.println("客户端连接异常: " + e.getMessage());
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                System.err.println("关闭客户端连接失败: " + e.getMessage());
            }
        }
    }
}

代码解释：

线程池创建：我们使用 Executors.newFixedThreadPool(10) 创建了一个大小为 10 的线程池，这意味着最多同时处理 10 个客户端请求。线程池的大小可以根据实际需求进行调整。
连接处理：服务端使用 ServerSocket.accept() 等待客户端的连接。当有客户端连接时，服务端会将客户端的 Socket 传递给线程池中的一个线程来处理请求。executorService.submit(new ClientHandler(clientSocket)) 会提交任务到线程池，由线程池中的线程来执行 ClientHandler 类中的 run() 方法。
客户端请求处理：在 ClientHandler 类的 run() 方法中，服务端通过 BufferedReader 获取客户端发送的消息并输出到控制台。每个客户端连接都会创建一个新的 ClientHandler 实例，这个实例会在独立的线程中处理该客户端的请求。
异常处理：我们在代码中加入了多个 try-catch 块来捕获并处理可能发生的异常。例如，服务端在处理客户端请求时可能会遇到 I/O 异常，因此我们需要通过捕获异常来避免服务端崩溃。

异常处理

在服务端编程中，异常处理是保证服务端稳定性和可靠性的关键。我们需要考虑到以下几种常见的异常情况，并进行适当的处理：

网络异常：例如，客户端无法连接到服务端，或者服务端无法与客户端建立连接。这类问题通常会抛出 IOException，我们需要捕获这些异常，并给出合理的提示信息，防止服务端崩溃。
I/O 异常：在与客户端进行数据交换时，可能会遇到读取数据时出现的问题。这类异常可以通过捕获 IOException 来处理。
线程池满的异常：如果线程池中的线程都在工作，且有新的连接请求，线程池将无法立即处理该请求。为了解决这个问题，我们可以设置合理的线程池大小，并使用队列来缓冲这些连接请求。

代码示例：

import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class EnhancedServer {
    // 创建线程池，最多处理 10 个客户端连接，队列大小为 50
    private static final ExecutorService executorService = new ThreadPoolExecutor(
            10, 10, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(50));

    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8080)) {
            System.out.println("服务端已启动，等待客户端连接...");

            while (true) {
                try {
                    // 等待客户端连接
                    Socket clientSocket = serverSocket.accept();
                    System.out.println("有客户端连接，准备处理...");
                    // 提交客户端处理任务
                    executorService.submit(new ClientHandler(clientSocket));
                } catch (IOException e) {
                    System.err.println("客户端连接错误: " + e.getMessage());
                }
            }
        } catch (IOException e) {
            System.err.println("服务端启动失败: " + e.getMessage());
        }
    }

    static class ClientHandler implements Runnable {
        private Socket clientSocket;

        public ClientHandler(Socket socket) {
            this.clientSocket = socket;
        }

        @Override
        public void run() {
            try {
                // 获取客户端输入流，读取消息
                BufferedReader input = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                String message;
                while ((message = input.readLine()) != null) {
                    System.out.println("接收到消息: " + message);
                }
            } catch (IOException e) {
                System.err.println("处理客户端请求时出错: " + e.getMessage());
            } finally {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    System.err.println("关闭连接失败: " + e.getMessage());
                }
            }
        }
    }
}

代码解释：

自定义线程池：我们使用 ThreadPoolExecutor 来创建一个线程池，并设置了最大线程数为 10，任务队列大小为 50。这样，最多可以处理 10 个并发客户端连接，如果线程池满了，新的连接请求将排队等待处理。
异常处理改进：我们对客户端连接过程中的异常进行了处理，确保即使某些客户端连接失败，也不会影响服务端的正常运行。对于服务端启动时的异常，我们使用 try-with-resources 来确保 ServerSocket 被正确关闭。