JavaSocket编程实例TCP服务端线程池

一、服务端回传服务类：

import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; import java.util.logging.Level; import java.util.logging.Logger;   public class EchoProtocol implements Runnable {   private static final int BUFSIZE = 32; // Size (in bytes) of I/O buffer   private Socket clientSocket; // Socket connect to client   private Logger logger; // Server logger     public EchoProtocol(Socket clientSocket, Logger logger) {     this.clientSocket = clientSocket;     this.logger = logger;   }     public static void handleEchoClient(Socket clientSocket, Logger logger) {     try {       // Get the input and output I/O streams from socket       InputStream in = clientSocket.getInputStream();       OutputStream out = clientSocket.getOutputStream();         int recvMsgSize; // Size of received message       int totalBytesEchoed = 0; // Bytes received from client       byte[] echoBuffer = new byte[BUFSIZE]; // Receive Buffer       // Receive until client closes connection, indicated by -1       while ((recvMsgSize = in.read(echoBuffer)) != -1) {         out.write(echoBuffer, 0, recvMsgSize);         totalBytesEchoed += recvMsgSize;       }         logger.info("Client " + clientSocket.getRemoteSocketAddress() + ", echoed " + total本文来源gaodai$ma#com搞$代*码*网(BytesEchoed + " bytes.");             } catch (IOException ex) {       logger.log(Level.WARNING, "Exception in echo protocol", ex);     } finally {       try {         clientSocket.close();       } catch (IOException e) {       }     }   }     public void run() {     handleEchoClient(this.clientSocket, this.logger);   } }

二、每个客户端请求都新启一个线程的Tcp服务端：

import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.logging.Logger;   public class TCPEchoServerThread {     public static void main(String[] args) throws IOException {     // Create a server socket to accept client connection requests     ServerSocket servSock = new ServerSocket(5500);       Logger logger = Logger.getLogger("practical");       // Run forever, accepting and spawning a thread for each connection     while (true) {       Socket clntSock = servSock.accept(); // Block waiting for connection       // Spawn thread to handle new connection       Thread thread = new Thread(new EchoProtocol(clntSock, logger));       thread.start();       logger.info("Created and started Thread " + thread.getName());     }     /* NOT REACHED */  } }

三、固定线程数的Tcp服务端：

import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.logging.Level; import java.util.logging.Logger;   public class TCPEchoServerPool {   public static void main(String[] args) throws IOException {     int threadPoolSize = 3; // Fixed ThreadPoolSize       final ServerSocket servSock = new ServerSocket(5500);     final Logger logger = Logger.getLogger("practical");       // Spawn a fixed number of threads to service clients     for (int i = 0; i import java.util.concurrent.*;   /**  * 任务执行者  *  * @author Watson Xu  * @since 1.0.0 
2013-6-8 上午10:33:09
  */public class ThreadPoolTaskExecutor {     private ThreadPoolTaskExecutor() {     }     private static ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactory() {     int count;       /* 执行器会在需要自行任务而线程池中没有线程的时候来调用该程序。对于callable类型的调用通过封装以后转化为runnable */     public Thread newThread(Runnable r) {       count++;       Thread invokeThread = new Thread(r);       invokeThread.setName("Courser Thread-" + count);       invokeThread.setDaemon(false);// //????????????         return invokeThread;     }   });     public static void invoke(Runnable task, TimeUnit unit, long timeout) throws TimeoutException, RuntimeException {     invoke(task, null, unit, timeout);   }     public static  T invoke(Runnable task, T result, TimeUnit unit, long timeout) throws TimeoutException,       RuntimeException {     Future future = executor.submit(task, result);     T t = null;     try {       t = future.get(timeout, unit);     } catch (TimeoutException e) {       throw new TimeoutException("Thread invoke timeout ...");     } catch (Exception e) {       throw new RuntimeException(e);     }     return t;   }     public static  T invoke(Callable task, TimeUnit unit, long timeout) throws TimeoutException, RuntimeException {     // 这里将任务提交给执行器，任务已经启动，这里是异步的。     Future future = executor.submit(task);     // System.out.println("Task aready in thread");     T t = null;     try {       /*        * 这里的操作是确认任务是否已经完成，有了这个操作以后        * 1)对invoke()的调用线程变成了等待任务完成状态        * 2)主线程可以接收子线程的处理结果        */      t = future.get(timeout, unit);     } catch (TimeoutException e) {       throw new TimeoutException("Thread invoke timeout ...");     } catch (Exception e) {       throw new RuntimeException(e);     }       return t;   } }

2.具有伸缩性的Tcp服务端：

import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.TimeUnit; import java.util.logging.Logger;   import demo.callable.ThreadPoolTaskExecutor;     public class TCPEchoServerExecutor {     public static void main(String[] args) throws IOException {     // Create a server socket to accept client connection requests     ServerSocket servSock = new ServerSocket(5500);       Logger logger = Logger.getLogger("practical");           // Run forever, accepting and spawning threads to service each connection     while (true) {       Socket clntSock = servSock.accept(); // Block waiting for connection       //executorService.submit(new EchoProtocol(clntSock, logger));       try {         ThreadPoolTaskExecutor.invoke(new EchoProtocol(clntSock, logger), TimeUnit.SECONDS, 3);       } catch (Exception e) {       }        //service.execute(new TimelimitEchoProtocol(clntSock, logger));     }     /* NOT REACHED */  } }

更多Java Socket编程实例- TCP服务端线程池相关文章请关注！