这有点爽的

　　简单应用了一下多线程，搞定了多客户端的问题。

　　之前只能有一个客户端接入，因为服务器只会accept()一次，然后就进入接收输入流的死循环了。

　　然后我趴在地上想了一下，主进程里死循环来accept()，然后每个客户端new一个新进程是不是就搞定了，越想越觉得有道理，于是就试了试。

　　另外每个进程里重新各new一个Socket和输入流，这样就不会跟主进程产生冲突，同时主进程里的这两个也就可以直接删掉了。

　　于是现在是各个进程各自处理自己的接收信息动作，互不干涉。

　　启动进程是start()不是run()哪。

　　现在的问题是服务器已经把该接收的都接收了，怎么把客户端发上来的消息再发给其他客户端呢。

　　不可能在服务器里放一个StringBuffer，虽然这样很稳妥，也能解决问题，但是这样消耗带宽越来越大……

　　另一种方法是客户端发上来消息之后先不更新自己的文本框内容，由服务器向所有客户端来发送，也就是说我发一条消息要发上去再下下来，是不是有点蛋疼，虽然这样也可以解决问题。

　　

　　诸君，我从小学开始就最擅长找笨办法了……

　　智商低好痛苦 _(:з」∠)_

import java.io.*;
import java.net.*;

/**
 * 服务器端，目前还是单纯的解包并在命令行打印，再下个版本改。
 * 1. 处理了端口已占用的异常。
 * 2. 客户端退出后不关闭进程。
 * 3. *重要内容* 改用多进程的方式，支持了多客户端接入。
 * 不过目前只能接收信息命令行打印。
 * 之后加上向其他客户端发送消息的功能。
 * 
 * @author mlxy
 * @version 0.6
 * */
public class SimChatServer {
    ServerSocket ss = null;
    int users;
    
    /** 服务器构造方法，只用来初始化已连接客户端数。*/
    public SimChatServer() {users = 0;}
    
    public static void main(String[] args) {
        SimChatServer server = new SimChatServer();
        
        // 尝试启动服务器，端口被占用则提示并退出。
        try {
            server.ss = new ServerSocket(2333);
        } catch (BindException e) {
            System.out.println("Port occupied.");
            System.exit(0);
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        // 死循环，等待客户端连接，连接成功则启动一个新线程。
        try {
            do {
                server.new ClientThread(server, server.ss.accept()).start();
                server.users++;
                System.out.println("Current clients: " + server.users);
            } while (server.users > 0);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        
    }
    
    /** 管理客户端退出的方法。*/
    private void clientOut() {
        users--;
        System.out.println("Current clients: " + users);
        
        // 所有客户端都断开之后关闭服务器。
        if (users == 0) {
            System.out.println("All clients are out, server abort.");
            try {
                ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 内部类。
     * 单个客户端线程，包含了处理客户端发来信息的方法。
     * 目前只能接收信息，之后再加上向客户端发包的功能。
     * 
     * @author mlxy
     * @version 0.5
     */
    class ClientThread extends Thread {
        SimChatServer server;
        Socket singleSocket;
        ObjectInputStream singleInput;
        
        /** 一个客户端线程的构造方法。*/
        public ClientThread(SimChatServer server, Socket singleSocket) {
            this.server = server;
            this.singleSocket = singleSocket;
            System.out.println("Client connected.");
            try {
                singleInput = new ObjectInputStream(singleSocket.getInputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            // 主运行部分，抓到客户端退出的异常就打印提示并退出。
            try {
                // 死循环，读包拆包打印。
                while (true) {
                    String[] packReceived = (String[]) singleInput.readObject();
                    System.out.println(packReceived[0] + ": " + packReceived[1]);
                }
                    
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (EOFException ex) {
                System.out.println("Client disconnected.");
            } catch (IOException exc) {
                exc.printStackTrace();
            } finally {
                // 关闭所有引用，释放资源。
                try {
                    if (singleSocket != null)
                        singleSocket.close();
                    if (singleInput != null)
                        singleInput.close();
                    
                    // 报告一个客户端退出。
                    server.clientOut();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
}