上一篇文章說到怎樣寫一個最簡單的Java Socket通信，但是在上一篇文章中的例子有一個問題就是Server只能接受一個Client請求，當第一個Client連接后就占據了這個位置，后續Client不能再繼續連接，所以需要做些改動，當Server沒接受到一個Client連接請求之后，都把處理流程放到一個獨立的線程里去運行，然后等待下一個Client連接請求，這樣就不會阻塞Server端接收請求了。每個獨立運行的程序在使用完Socket對象之后要將其關閉。

具體代碼如下：

package com.googlecode.garbagecan.test.socket.sample2;  
 
import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.io.PrintWriter;  
import java.net.ServerSocket;  
import java.net.Socket;  
 
public class MyServer {  
    public static void main(String[] args) throws IOException {  
        ServerSocket server = new ServerSocket(10000);  
          
        while (true) {  
            Socket socket = server.accept();  
            invoke(socket);  
        }  
    }  
      
    private static void invoke(final Socket client) throws IOException {  
        new Thread(new Runnable() {  
            public void run() {  
                BufferedReader in = null;  
                PrintWriter out = null;  
                try {  
                    in = new BufferedReader(new InputStreamReader(client.getInputStream()));  
                    out = new PrintWriter(client.getOutputStream());  
 
                    while (true) {  
                        String msg = in.readLine();  
                        System.out.println(msg);  
                        out.println("Server received " + msg);  
                        out.flush();  
                        if (msg.equals("bye")) {  
                            break;  
                        }  
                    }  
                } catch(IOException ex) {  
                    ex.printStackTrace();  
                } finally {  
                    try {  
                        in.close();  
                    } catch (Exception e) {}  
                    try {  
                        out.close();  
                    } catch (Exception e) {}  
                    try {  
                        client.close();  
                    } catch (Exception e) {}  
                }  
            }  
        }).start();  
    }  
} 

下面是Client程序代碼：

package com.googlecode.garbagecan.test.socket.sample2;  
 
import java.io.BufferedReader;  
import java.io.InputStreamReader;  
import java.io.PrintWriter;  
import java.net.Socket;  
 
public class MyClient {  
    public static void main(String[] args) throws Exception {  
        Socket socket = new Socket("localhost", 10000);  
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
        PrintWriter out = new PrintWriter(socket.getOutputStream());  
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));  
 
        while (true) {  
            String msg = reader.readLine();  
            out.println(msg);  
            out.flush();  
            if (msg.equals("bye")) {  
                break;  
            }  
            System.out.println(in.readLine());  
        }  
        socket.close();  
    }  
}  

測試，首先運行MyServer類，然后運行兩個MyClient類，然后分別在每個MyClient的提示符下輸入字符串，就可以看到Server可以分別接收處理每個Client的請求了。

原文鏈接：http://blog.csdn.net/kongxx/article/details/7259465

【編輯推薦】

1. Java Socket實戰之一：單線程通信
2. 對于Java類加載過程中的順序問題探究
3. Java多線程之消費者生產者模式
4. 深入理解Java對象序列化
5. 菜鳥入門Java語言學習的要點