多线程Java Socket编程示例(http://www.blogjava.net/sterning/archive/2007/10/15/152940.html)

这篇做为学习孙卫琴<<Java网络编程精解>>的学习笔记吧.其中采用Java 5的ExecutorService来进行线程池的方式实现多线程,模拟客户端多用户向同一服务器端发送请求.
1.服务端

1. package sterning;
2. import java.io.BufferedReader;
3. import java.io.IOException;
4. import java.io.InputStream;
5. import java.io.InputStreamReader;
6. import java.io.OutputStream;
7. import java.io.PrintWriter;
8. import java.net.*;
9. import java.util.concurrent.*;
10. public class MultiThreadServer {
11.     private int port=8821;
12.     private ServerSocket serverSocket;
13.     private ExecutorService executorService;//线程池
14.     private final int POOL_SIZE=10;//单个CPU线程池大小
15.     
16.     public MultiThreadServer() throws IOException{
17.         serverSocket=new ServerSocket(port);
18.         //Runtime的availableProcessor()方法返回当前系统的CPU数目.
19.         executorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*POOL_SIZE);
20.         System.out.println("服务器启动");
21.     }
22.     
23.     public void service(){
24.         while(true){
25.             Socket socket=null;
26.             try {
27.                 //接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接
28.                 socket=serverSocket.accept();
29.                 executorService.execute(new Handler(socket));
30.                 
31.             } catch (Exception e) {
32.                 e.printStackTrace();
33.             }
34.         }
35.     }
36.     
37.     public static void main(String[] args) throws IOException {
38.         new MultiThreadServer().service();
39.     }
40. }
41. class Handler implements Runnable{
42.     private Socket socket;
43.     public Handler(Socket socket){
44.         this.socket=socket;
45.     }
46.     private PrintWriter getWriter(Socket socket) throws IOException{
47.         OutputStream socketOut=socket.getOutputStream();
48.         return new PrintWriter(socketOut,true);
49.     }
50.     private BufferedReader getReader(Socket socket) throws IOException{
51.         InputStream socketIn=socket.getInputStream();
52.         return new BufferedReader(new InputStreamReader(socketIn));
53.     }
54.     public String echo(String msg){
55.         return "echo:"+msg;
56.     }
57.     public void run(){
58.         try {
59.             System.out.println("New connection accepted "+socket.getInetAddress()+":"+socket.getPort());
60.             BufferedReader br=getReader(socket);
61.             PrintWriter pw=getWriter(socket);
62.             String msg=null;
63.             while((msg=br.readLine())!=null){
64.                 System.out.println(msg);
65.                 pw.println(echo(msg));
66.                 if(msg.equals("bye"))
67.                     break;
68.             }
69.         } catch (IOException e) {
70.             e.printStackTrace();
71.         }finally{
72.             try {
73.                 if(socket!=null)
74.                     socket.close();
75.             } catch (IOException e) {
76.                 e.printStackTrace();
77.             }
78.         }
79.     }
80. }

2.客户端

1. package sterning;
2. import java.io.BufferedReader;
3. import java.io.IOException;
4. import java.io.InputStreamReader;
5. import java.io.OutputStream;
6. import java.net.Socket;
7. import java.util.concurrent.ExecutorService;
8. import java.util.concurrent.Executors;
9. public class MultiThreadClient {
10.     
11.     public static void main(String[] args) {
12.         int numTasks = 10;
13.         
14.         ExecutorService exec = Executors.newCachedThreadPool();
15.         for (int i = 0; i < numTasks; i++) {
16.             exec.execute(createTask(i));
17.         }
18.     }
19.     // 定义一个简单的任务
20.     private static Runnable createTask(final int taskID) {
21.         return new Runnable() {
22.             private Socket socket = null;
23.             private int port=8821;
24.             public void run() {
25.                 System.out.println("Task " + taskID + ":start");
26.                 try {                    
27.                     socket = new Socket("localhost", port);
28.                     // 发送关闭命令
29.                     OutputStream socketOut = socket.getOutputStream();
30.                     socketOut.write("shutdown/r/n".getBytes());
31.                     // 接收服务器的反馈
32.                     BufferedReader br = new BufferedReader(
33.                             new InputStreamReader(socket.getInputStream()));
34.                     String msg = null;
35.                     while ((msg = br.readLine()) != null)
36.                         System.out.println(msg);
37.                 } catch (IOException e) {                    
38.                     e.printStackTrace();
39.                 }
40.             }
41.         };
42.     }
43. }

从而实现了多个客户端向服务器端发送请求,服务器端采用多线程的方式来处理的情况.再结合我之前的例子---Java基于Socket文件传输示例,就可以实现多线程文件的传输了

<script type="text/javascript"> </script> <script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript"></script>