Ejemplo de programación de socket Java (iii) - grupo de subprocesos del servidor 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; El ecoprotocol de clase pública implementa Runnable {private static final int bufsize = 32; // tamaño (en bytes) de Buffer de E/S buffer privado Socket Clientsocket; // Socket Connect a Client Private Logger Logger; // Servidor Logger public EchoProtocol (Socket Clientsocket, Logger Logger) {this.clientsocket = Clientsocket; this.logger = logger; } public static void handleEchoclient (Socket Clientsocket, Logger Logger) {try {// Obtenga las secuencias de E/S de entrada y salida de Socket InputStream in = Clientsocket.getInputStream (); OutputStream out = Clientsocket.getOutputStream (); int recvmSgSize; // Tamaño del mensaje recibido int TotalByteseChoed = 0; // bytes recibidos del cliente byte [] echobuffer = new byte [bufsize]; // Recibe búfer // Recibir hasta que el cliente cierre la conexión, indicado por -1 while ((recvmSgSize = in.read (echobuffer))! = -1) {out.write (echobuffer, 0, recvmSgSize); TotalByTeseChoed += RecvmSgSize; } logger.info ("cliente" + clientsocket.getRemotesocketAddress () + ", se eco" + totalByTeseChoed + "bytes"); } catch (ioException ex) {logger.log (nivel.warning, "excepción en el protocolo echo", ex); } Finalmente {try {clientsocket.close (); } catch (ioException e) {}}} public void run () {handleEctOclient (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) lanza ioexception {// crea un socket de servidor para aceptar solicitudes de conexión del cliente Serversocket ServSock = new Serversocket (5500); Logger logger = logger.getLogger ("práctico"); // ejecutar para siempre, aceptando y generando un hilo para cada conexión mientras (verdadero) {socket clntsock = servsock.accept (); // bloquear la conexión // hilo de desove para manejar el nuevo hilo de conexión de conexión = nuevo hilo (nuevo ecoprotocol (clntsock, logger)); Thread.Start (); logger.info ("creó e inició el hilo" + thread.getName ()); } / * No alcanzado * /}}

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

 import java.io.ioException; import java.net.serversocket; import java.net.socket; import java.util.logging.level; import java.util.logging.logger; clase pública tcpechoserverPool {public static void main (string [] args) lanza ioexception {int threadpoolSize = 3; // Servsock final de Servversock de Servversock final de ThreadPoolSize = New Serversocket (5500); Final logger logger = logger.getLogger ("práctico"); // genera un número fijo de subprocesos a los clientes de servicio para (int i = 0; i <threadpoolsize; i ++) {hilo hilado = new thread () {public void run () {while (true) {try {socket clntsock = servsock.accept (); // espere una conexión ecoprotocol.handleechoclient (clntsock, logger); // manejarlo} Catch (ioException ex) {logger.log (nivel.warning, "Cliente de aceptación de aceptación fallida", ex); }}}}; Thread.Start (); logger.info ("creó y inició thread =" + thread.getName ()); }}}

四、使用线程池 (使用 使用 Spring 的线程次会有队列、最大线程数、最小线程数和超时时间的概念)

1. 线程池工具类 ：

 import java.util.concurrent.*; /** * 任务执行者 * * @Author Watson Xu * @since 1.0.0 <p> 2013-6-8 上午 10:33:09 </p> */public class ThreadPoolTASKEXECUTOR {private ThreadPoolTASKEXECUTOR () {} private Static ExecutorService Ejecutor = Executors.NewCachedPool (New Threadfactory ().执行器会在需要自行任务而线程池中没有线程的时候来调用该程序。对于 Callable 类型的调用通过封装以后转化为 Runnable */Public Thread NewThread (Runnable R) {Count ++; public static void Invoke (tarea ejecutable, unidad de tiempo de tiempo, tiempo de espera largo) lanza TimeOutException, RuntimeException {Invoke (tarea, nulo, unidad, tiempo de espera); } public static <t> t Invoke (tarea ejecutable, resultado t, unidad de tiempo de tiempo, tiempo de espera largo) lanza TimeOutException, RuntimeException {Future <T> Future = Executor.submit (tarea, resultado); T t = nulo; intente {t = futuro.get (Tiempo de espera, unidad); } Catch (TimeOutException e) {arrojar una nueva TimeOutException ("TIEMPO DE TIEMPO DE INVOCADO ..."); } catch (Exception e) {Throw New RuntimeException (e); } return t; } public static <t> t Invoke (Task Callable <T>, unidad de tiempo de tiempo, tiempo de espera largo) lanza TimeOutException, RuntimeException {// 这里将任务提交给执行器 ， 任务已经启动 这里是异步的。 这里是异步的。 Future <T> Future = Ejecutor.submit (tarea); // system.out.println ("tarea aready en hilo"); T t = nulo; Pruebe { / * * 这里的操作是确认任务是否已经完成 ， 有了这个操作以后 * 1) 对 Invoke () 的调用线程变成了等待任务完成状态 * 2) 主线程可以接收子线程的处理结果 * / t = Future.get (Tiempo de espera, Unidad); } Catch (TimeOutException e) {arrojar una nueva TimeOutException ("TIEMPO DE TIEMPO DE INVOCADO ..."); } 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; importación de importación.callable.threadpooltaskexecutor; public class tcpechoserverExecutor {public static void main (string [] args) lanza ioexception {// crea un socket de servidor para aceptar solicitudes de conexión del cliente ServerSocket ServSock = new Serversocket (5500); Logger logger = logger.getLogger ("práctico"); // Ejecute para siempre, aceptando y generando subprocesos para dar servicio a cada conexión mientras (verdadero) {socket clntsock = servsock.accept (); // bloquear la conexión //executorservice.submit(new ecoprotocol (clntsock, logger)); Pruebe {ThreadPoolTaskExecutor.invoke (nuevo ecoprotocol (Clntsock, Logger), TimeUnit.seconds, 3); } capt (excepción e) {} //service.execute(new timelimitEchoProtocol (clntsock, logger)); } / * No alcanzado * /}}

以上就是本文的全部内容 ， 查看更多 java 的语法 ， 大家可以关注 ： 《pensando en java 中文手册》、《 jdk 1.7 参考手册官方英文版》、《 jdk 1.6 api java 中文参考手册》、《 jdk 1.5 api java 中文参考手册》 也希望大家多多支持武林网。 也希望大家多多支持武林网。