脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java Socket TCP服务端线程池

Java Socket编程实例（三）- TCP服务端线程池

 更新时间：2016年06月15日 09:35:26   作者：kingxss  
这篇文章主要讲解Java Socket编程中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 " + totalBytesEchoed + " 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 < threadPoolSize; i++) { 
      Thread thread = new Thread() { 
        public void run() { 
          while (true) { 
            try { 
              Socket clntSock = servSock.accept(); // Wait for a connection 
              EchoProtocol.handleEchoClient(clntSock, logger); // Handle it 
            } catch (IOException ex) { 
              logger.log(Level.WARNING, "Client accept failed", ex); 
            } 
          } 
        } 
      }; 
      thread.start(); 
      logger.info("Created and started 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 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> T invoke(Runnable task, T result, TimeUnit unit, long timeout) throws TimeoutException, 
      RuntimeException { 
    Future<T> 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> T invoke(Callable<T> task, TimeUnit unit, long timeout) throws TimeoutException, RuntimeException { 
    // 这里将任务提交给执行器，任务已经启动，这里是异步的。 
    Future<T> 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的语法，大家可以关注：《Thinking in Java 中文手册》、《JDK 1.7 参考手册官方英文版》、《JDK 1.6 API java 中文参考手册》、《JDK 1.5 API java 中文参考手册》，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • java开发Activiti进阶篇流程实例详解

    java开发Activiti进阶篇流程实例详解

    这篇文章主要为大家介绍了java开发Activiti进阶篇流程实例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-08-08
  • 图文详解Java中的字节输入与输出流

    图文详解Java中的字节输入与输出流

    在Java中所有数据都是使用流读写的,流是一组有序的数据序列,将数据从一个地方带到另一个地方,这篇文章主要给大家介绍了关于Java中字节输入与输出流的相关资料,需要的朋友可以参考下
    2021-08-08
  • SpringBoot如何访问html和js等静态资源配置

    SpringBoot如何访问html和js等静态资源配置

    这篇文章主要介绍了SpringBoot如何访问html和js等静态资源配置，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-03-03
  • URL @PathVariable 变量的匹配原理分析

    URL @PathVariable 变量的匹配原理分析

    这篇文章主要介绍了URL @PathVariable 变量的匹配原理分析，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-10-10
  • SpringBoot中间件封装限流器的方案详解

    SpringBoot中间件封装限流器的方案详解

    这篇文章主要介绍了SpringBoot中间件封装限流器,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2023-07-07
  • spring-session简介及实现原理源码分析

    spring-session简介及实现原理源码分析

    这篇文章主要介绍了spring-session简介及实现原理源码分析，具有一定参考价值，需要的朋友可以了解下。
    2017-11-11
  • 使用Jmeter进行http接口测试的实践

    使用Jmeter进行http接口测试的实践

    本文主要针对http接口进行测试，使用Jmeter工具实现。文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-11-11
  • 解析Java实现随机验证码功能的方法详解

    解析Java实现随机验证码功能的方法详解

    本篇文章是对Java实现随机验证码功能的方法进行了详细的分析介绍，需要的朋友参考下
    2013-05-05
  • GsonFormat快速生成JSon实体类的实现

    GsonFormat快速生成JSon实体类的实现

    GsonFormat主要用于使用Gson库将JSONObject格式的String 解析成实体，本文主要介绍了GsonFormat快速生成JSon实体类的实现，具有一定的参考价值，感兴趣的可以了解一下
    2023-05-05
  • Java Swing中JList选择事件监听器ListSelectionListener用法示例

    Java Swing中JList选择事件监听器ListSelectionListener用法示例

    这篇文章主要介绍了Java Swing中JList选择事件监听器ListSelectionListener用法,结合具体实例形式分析了中JList选择事件监听器ListSelectionListener的功能、使用方法及相关注意事项,需要的朋友可以参考下
    2017-11-11

最新评论