Java多线程实现聊天客户端和服务器

在Java中，多线程技术可以帮助我们实现一个简单的聊天客户端和服务器。本文将会详细讲解如何使用Java多线程技术实现。

前置知识

在学习本文之前，需要具备Java基础知识、Java IO基础知识以及基本的多线程编程知识。

设计聊天客户端

我们首先需要设计一个简单的聊天客户端，客户端需要完成以下功能：

• 连接服务器
• 发送消息
• 接收服务器消息
• 关闭连接

首先需要创建一个Socket对象，连接上服务器。当连接成功后，需要分别创建两个线程，一个线程负责接收来自服务器的消息，另一个线程负责发送消息给服务器。

public class ChatClient {
    private Socket clientSocket;
    private String serverAddress;
    private int serverPort;
    private Scanner scanner;
    private PrintWriter printWriter;

    public ChatClient(String serverAddress, int serverPort) {
        this.serverAddress = serverAddress;
        this.serverPort = serverPort;
        this.scanner = new Scanner(System.in);
    }

    public void connect() throws IOException {
        clientSocket = new Socket(serverAddress, serverPort);
        System.out.println("Connected to the server.");

        //创建接收消息的线程
        Thread receiverThread = new Thread(new MessageReceiver());
        receiverThread.start();

        //创建发送消息的线程
        Thread senderThread = new Thread(new MessageSender());
        senderThread.start();
    }

    public void close() throws IOException {
        clientSocket.close();
    }

    private class MessageReceiver implements Runnable {
        @Override
        public void run() {
            try {
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                String message;
                while ((message = bufferedReader.readLine()) != null) {
                    System.out.println(message);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private class MessageSender implements Runnable {
        @Override
        public void run() {
            try {
                printWriter = new PrintWriter(clientSocket.getOutputStream(), true);
                while (true) {
                    String message = scanner.nextLine();
                    printWriter.println(message);
                    printWriter.flush();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ChatClient chatClient = new ChatClient("127.0.0.1", 9000);

        try {
            chatClient.connect();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

设计聊天服务器

服务器需要实现以下功能：

• 监听客户端请求
• 接受客户端请求
• 广播消息
• 记录客户端连接和断开事件

需要使用Java的ServerSocket类来监听客户端请求，每当服务器接收到一个客户端连接请求，就会为这个请求创建一个Socket对象，然后接收和发送消息。此外，为了实现多个客户端之间的消息传递，我们需要使用List存储客户端Socket对象，对于每一个客户端，我们都需要为其创建一个新的线程来接收来自客户端的消息并发送至其他客户端。

public class ChatServer {
    private ServerSocket serverSocket;
    private List<Socket> clients;
    private ExecutorService executorService;

    public ChatServer() {
        clients = new ArrayList<>();
        executorService = Executors.newCachedThreadPool();
    }

    public void start(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        System.out.println("Server started.");

        while (true) {
            System.out.println("Waiting for client connections...");
            Socket clientSocket = serverSocket.accept();

            System.out.println("Client connected: " + clientSocket);

            //保存客户端Socket
            clients.add(clientSocket);

            //为这个客户端创建一个线程
            executorService.execute(new MessageHandler(clientSocket));
        }
    }

    public void stop() throws IOException {
        executorService.shutdown();

        for (Socket socket : clients) {
            if (!socket.isClosed()) {
                socket.close();
            }
        }

        clients.clear();
        serverSocket.close();
    }

    public void broadcast(String message) throws IOException {
        for (Socket socket : clients) {
            PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
            writer.println(message);
            writer.flush();
        }
    }

    private class MessageHandler implements Runnable {
        private Socket clientSocket;

        public MessageHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }

        @Override
        public void run() {
            try {
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

                String message = null;
                while ((message = bufferedReader.readLine()) != null) {
                    System.out.println(message);

                    //向所有客户端广播消息
                    broadcast(message);
                }

                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                clients.remove(clientSocket);
                System.out.println("Client disconnected: " + clientSocket);

                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        ChatServer chatServer = new ChatServer();

        try {
            chatServer.start(9000);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

示例说明

下面是一个简单的示例，演示了如何使用ChatClient和ChatServer来实现一个简单的聊天应用。

启动ChatServer.java程序：

public static void main(String[] args) {
    ChatServer chatServer = new ChatServer();

    try {
        chatServer.start(9000);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

启动ChatClient.java程序：

public static void main(String[] args) {
    ChatClient chatClient = new ChatClient("127.0.0.1", 9000);

    try {
        chatClient.connect();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

此时，在ChatClient程序中输入一些消息，可以看到这些消息被广播到了所有已连接的客户端中。

总结

使用Java多线程技术可以很容易地实现一个简单的聊天客户端和服务器，同时也可以使我们更好地理解多线程编程的思想。在实际开发中，需要注意多线程带来的线程安全问题，避免出现并发问题。