while (true) {
    Socket socket = null;
    try {
        // 接收客戶連接
        socket = serverSocket.accept();
        // 從socket中獲得輸入流與輸出流，與客戶通信
        ...
    } catch(IOException e) {
        e.printStackTrace()
    } finally {
        try {
            if(socket != null) {
                // 斷開連接
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public class EchoServer {
    private int port = 8000;
    private ServerSocket serverSocket;
    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        System.out.println("服務器啟動");
    }
    public void service() {
        while(true) {
            Socket socket = null;
            try {
                // 接教客戶連接
                socket = serverSocket.accept();
                // 創(chuàng)建一個工作線程
                Thread workThread = new Thread(new Handler(socket));
                // 啟動工作線程
                workThread.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String args[])throws TOException {
        new EchoServer().service();
    }
    // 負責與單個客戶的通信   
    class Handler implements Runnable {
        private Socket socket;
        pub1ic Handler(Socket socket) {
            this.socket = socket;
        }
        private PrintWriter getWriter(Socket socket) throws IOException {...}
        private BufferedReader getReader(Socket socket) throws IOException {...}
        public String echo(String msg) {...}
        public void run() {
            try {
                System.out.println("New connection accepted" + socket.getInetAddress() + ":" + socket.getPort());
                BufferedReader br = getReader(socket);
                PrintWriter pw = getWriter(socket);
                String msg = null;
                // 接收和發(fā)送數(shù)據(jù)，直到通信結束
                while ((msg = br.readLine()) != null) {
                    System.out.println("from "+ socket.getInetAddress() + ":" + socket.getPort() + ">" + msg);
                    pw.println(echo(msg));
                    if (msg.equals("bye")) break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    // 斷開連接
                    if(socket != nulll) socket.close();
                } catch (IOException e) {
                    e,printStackTrace();
                }
            }
        }
    }
}

public class ThreadPool extends ThreadGroup {
    // 線程池是否關閉
    private boolean isClosed = false;
    // 表示工作隊列
    private LinkedList<Runnable> workQueue;
    // 表示線程池ID
    private static int threadPoolID;
    // 表示工作線程ID
    // poolSize 指定線程池中的工作線程數(shù)目
    public ThreadPool(int poolSize) {
        super("ThreadPool-"+ (threadPoolID++));
        setDaemon(true);
        // 創(chuàng)建工作隊列
        workQueue = new LinkedList<Runnable>();
        for (int i = 0; i < poolSize; i++) {
            // 創(chuàng)建并啟動工作線程
            new WorkThread().start(); 
        }
    }
    /**
     * 向工作隊列中加入一個新任務，由工作線程去執(zhí)行任務
     */
    public synchronized void execute(Runnable tank) {
        // 線程池被關則拋出IllegalStateException異常
        if(isClosed) {
            throw new IllegalStateException();
        }
        if(task != null) {
            workQueue.add(task);
            // 喚醒正在getTask()方法中等待任務的工作線限
            notify();
        }
    }
    /**
     * 從工作隊列中取出一個任務，工作線程會調用此方法
     */
    protected synchronized Runnable getTask() throws InterruptedException {
        while(workQueue,size() == 0) {
            if (isClosed) return null;
            wait(); // 如果工作隊列中沒有任務，就等待任務
        }
        return workQueue.removeFirst();
    }
    /**
     * 關閉線程池
     */
    public synchronized void close() {
        if(!isClosed) {
            isClosed = true;
            // 清空工作隊列
            workQueue.clear();
            // 中斷所有的工作線程，該方法繼承自ThreadGroup類
            interrupt();
        }
    }
    /**
     * 等待工作線程把所有任務執(zhí)行完
     */
    public void join() {
        synchronized (this) {
            isClosed = true;
            // 喚醒還在getTask()方法中等待任務的工作線程
            notifyAll();
        }
        Thread[] threads = new Thread[activeCount()];
        // enumerate()方法繼承自ThreadGroup類獲得線程組中當前所有活著的工作線程
        int count = enumerate(threads);
        // 等待所有工作線程運行結束
        for(int i = 0; i < count; i++) {
            try {
                // 等待工作線程運行結束
                threads[i].join();
            } catch((InterruptedException ex) {}
        }
    }
    /**
     * 內(nèi)部類:工作線程
     */
    private class WorkThread extends Thread {
        public WorkThread() {
            // 加入當前 ThreadPool 線程組
            super(ThreadPool.this, "WorkThread-" + (threadID++));
        }
        public void run() {
            // isInterrupted()方法承自Thread類，判斷線程是否被中斷
            while (!isInterrupted()) {
                Runnable task = null;
                try {
                    // 取出任務
                    task = getTask();
                } catch(InterruptedException ex) {}
                // 如果 getTask() 返回 nu11 或者線程執(zhí)行 getTask() 時被中斷，則結束此線程
                if(task != null) return;
                // 運行任務，異常在catch代碼塊中被捕獲
                try {
                    task.run();
                } catch(Throwable t) {
                    t.printStackTrace();
                }
            }
        }
    }
}

publlc class EchoServer {
    private int port = 8000;
    private ServerSocket serverSocket;
    private ThreadPool threadPool;	// 線程港
    private final int POOL_SIZE = 4;	// 單個CPU時線程池中工作線程的數(shù)目
    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        // 創(chuàng)建線程池
        // Runtime 的 availableProcessors() 方法返回當前系統(tǒng)的CPU的數(shù)目
        // 系統(tǒng)的CPU越多，線程池中工作線程的數(shù)目也越多
        threadPool= new ThreadPool(
        	Runtime.getRuntime().availableProcessors() * POOL_SIZE);
        System.out.println("服務器啟動");
    }
    public void service() {
        while (true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();
                // 把與客戶通信的任務交給線程池
                threadPool.execute(new Handler(socket));
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String args[])throws TOException {
        new EchoServer().service();
    }
    // 負責與單個客戶的通信，與上例類似
    class Handler implements Runnable {...}
}

public class Echoserver {
    private int port = 8000;
    private ServerSocket serverSocket;
    // 線程池
    private ExecutorService executorService;
    // 單個CPU時線程池中工作線程的數(shù)目
    private final int POOL_SIZE = 4;
    public EchoServer() throws IOException {
        serverSocket = new ServerSocket(port);
        // 創(chuàng)建線程池
        // Runtime 的 availableProcessors() 方法返回當前系統(tǒng)的CPU的數(shù)目
        // 系統(tǒng)的CPU越多，線程池中工作線程的數(shù)目也越多
        executorService = Executors.newFixedThreadPool(
        	Runtime.getRuntime().availableProcessors() * POOL_SIZE);
        System.out.println("服務器啟動");
    }
    public void service() {
        while(true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();
                executorService.execute(new Handler(socket));
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
     public static void main(String args[])throws TOException {
        new EchoServer().service();
    }
    // 負責與單個客戶的通信，與上例類似
    class Handler implements Runnable {...}
}