采取Java 5的ExecutorService实现线程池

采用Java 5的ExecutorService实现线程池

采用Java 5的ExecutorService来进行线程池的方式实现多线程,模拟客户端多用户向同一服务器端发送请求。

1.服务端

# import java.io.BufferedReader;     
# import java.io.IOException;     
# import java.io.InputStream;     
# import java.io.InputStreamReader;     
# import java.io.OutputStream;     
# import java.io.PrintWriter;     
# import java.net.*;     
# import java.util.concurrent.*;     
#     
# public class MultiThreadServer {     
#     private int port=8821;     
#     private ServerSocket serverSocket;     
#     private ExecutorService executorService;//线程池     
#     private final int POOL_SIZE=10;//单个CPU线程池大小     
#          
#     public MultiThreadServer() throws IOException{     
#         serverSocket=new ServerSocket(port);     
#         //Runtime的availableProcessor()方法返回当前系统的CPU数目.     
#         executorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*POOL_SIZE);     
#         System.out.println("服务器启动");     
#     }     
#          
#     public void service(){     
#         while(true){     
#             Socket socket=null;     
#             try {     
#                 //接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接     
#                 socket=serverSocket.accept();     
#                 executorService.execute(new Handler(socket));     
#                      
#             } catch (Exception e) {     
#                 e.printStackTrace();     
#             }     
#         }     
#     }     
#          
#     public static void main(String[] args) throws IOException {     
#         new MultiThreadServer().service();     
#     }     
#     
# }     
#     
# class Handler implements Runnable{     
#     private Socket socket;     
#     public Handler(Socket socket){     
#         this.socket=socket;     
#     }     
#     private PrintWriter getWriter(Socket socket) throws IOException{     
#         OutputStream socketOut=socket.getOutputStream();     
#         return new PrintWriter(socketOut,true);     
#     }     
#     private BufferedReader getReader(Socket socket) throws IOException{     
#         InputStream socketIn=socket.getInputStream();     
#         return new BufferedReader(new InputStreamReader(socketIn));     
#     }     
#     public String echo(String msg){     
#         return "echo:"+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;     
#             while((msg=br.readLine())!=null){     
#                 System.out.println(msg);     
#                 pw.println(echo(msg));     
#                 if(msg.equals("bye"))     
#                     break;     
#             }     
#         } catch (IOException e) {     
#             e.printStackTrace();     
#         }finally{     
#             try {     
#                 if(socket!=null)     
#                     socket.close();     
#             } catch (IOException e) {     
#                 e.printStackTrace();     
#             }     
#         }     
#     }     
# }

2.客户端

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

从而实现了多个客户端向服务器端发送请求,服务器端采用多线程的方式来处理的情况。

原文摘自：http://blog.csdn.net/flowerknight/archive/2009/06/14/4269052.aspx

采取Java 5的ExecutorService实现线程池

相关推荐