ServerSocket 用法详解

本篇文章观点和例子来自 《Java网络编程精解》， 作者为孙卫琴， 出版社为电子工业出版社。

      在客户/服务器通信模式中, 服务器端需要创建监听端口的 ServerSocket, ServerSocket 负责接收客户连接请求. 本章首先介绍 ServerSocket 类的各个构造方法, 以及成员的用法, 接着介绍服务器如何用多线程来处理与多个客户的通信任务.

      本章提供线程池的一种实现方法. 线程池包括一个工作队列和若干工作线程. 服务器程序向工作队列中加入与客户通信的任务, 工作线程不断从工作队列中取出任务并执行它. 本章还介绍了 java.util.concurrent 包中的线程池类的用法, 在服务器程序中可以直接使用他们.

 

 一. 构造 ServerSocket

 

      ServerSocket 的构造方法有以下几种重载形式:

• ServerSocket() throws IOException
• ServerSocket(int port) throws IOException
• ServerSocket(int port, int backlog) throws IOException
• ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException

      在以上构造方法中, 参数 port 指定服务器要绑定的端口( 服务器要监听的端口), 参数 backlog 指定客户连接请求队列的长度, 参数 bindAddr 指定服务器要绑定的IP 地址.

 

1.1 绑定端口

 

      除了第一个不带参数的构造方法以外, 其他构造方法都会使服务器与特定端口绑定, 该端口有参数 port 指定. 例如, 以下代码创建了一个与 80 端口绑定的服务器:

       ServerSocket serverSocket = new ServerSocket(80);                                  

      如果运行时无法绑定到 80 端口, 以上代码会抛出 IOException, 更确切地说, 是抛出 BindException, 它是 IOException 的子类. BindException 一般是由以下原因造成的:

• 端口已经被其他服务器进程占用;
• 在某些操作系统中, 如果没有以超级用户的身份来运行服务器程序, 那么操作系统不允许服务器绑定到 1-1023 之间的端口.

      如果把参数 port 设为 0, 表示由操作系统来为服务器分配一个任意可用的端口. 有操作系统分配的端口也称为匿名端口. 对于多数服务器, 会使用明确的端口, 而不会使用匿名端口, 因为客户程序需要事先知道服务器的端口, 才能方便地访问服务器. 在某些场合, 匿名端口有着特殊的用途, 本章 四 会对此作介绍.

 

1.2 设定客户连接请求队列的长度

 

      当服务器进程运行时, 可能会同时监听到多个客户的连接请求. 例如, 每当一个客户进程执行以下代码:

       Socket socket = new Socket("www.javathinker.org", 80);                                             

 

      就意味着在远程 www.javathinker.org 主机的 80 端口上, 监听到了一个客户的连接请求. 管理客户连接请求的任务是由操作系统来完成的. 操作系统把这些连接请求存储在一个先进先出的队列中. 许多操作系统限定了队列的最大长度, 一般为 50 . 当队列中的连接请求达到了队列的最大容量时, 服务器进程所在的主机会拒绝新的连接请求. 只有当服务器进程通过 ServerSocket 的 accept() 方法从队列中取出连接请求, 使队列腾出空位时, 队列才能继续加入新的连接请求.

 

      对于客户进程, 如果它发出的连接请求被加入到服务器的请求连接队列中, 就意味着客户与服务器的连接建立成功, 客户进程从 Socket 构造方法中正常返回. 如果客户进程发出的连接请求被服务器拒绝, Socket 构造方法就会抛出 ConnectionException.

 

Tips: 创建绑定端口的服务器进程后, 当客户进程的 Socket构造方法返回成功, 表示客户进程的连接请求被加入到服务器进程的请求连接队列中. 虽然客户端成功返回 Socket对象, 但是还没跟服务器进程形成一条通信线路. 必须在服务器进程通过 ServerSocket 的 accept() 方法从请求连接队列中取出连接请求, 并返回一个Socket 对象后, 服务器进程这个Socket 对象才与客户端的 Socket 对象形成一条通信线路.

 

      ServerSocket 构造方法的 backlog 参数用来显式设置连接请求队列的长度, 它将覆盖操作系统限定的队列的最大长度. 值得注意的是, 在以下几种情况中, 仍然会采用操作系统限定的队列的最大长度:

• backlog 参数的值大于操作系统限定的队列的最大长度;
• backlog 参数的值小于或等于0;
• 在ServerSocket 构造方法中没有设置 backlog 参数.

      以下的 Client.java 和 Server.java 用来演示服务器的连接请求队列的特性.

 

      Client.java

 

import java.net.Socket;

public class Client {

 public static void main(String[] args) throws Exception{
  final int length = 100;
  String host = "localhost";
  int port = 1122;
  Socket[] socket = new Socket[length];
  for(int i = 0;i<length;i++){
   socket[i] = new Socket(host,port);
   System.out.println("第"+(i+1)+"次连接成功！");
  }
  Thread.sleep(3000);
  for(int i=0;i<length;i++){
   socket[i].close();
  }
 }
}

 

Server.java 

 

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
 private int port = 1122;
 private ServerSocket serverSocket;
 
 public Server() throws Exception{
  serverSocket = new ServerSocket(port,3);
  System.out.println("服务器启动!");
 }

 public void service(){
  while(true){
   Socket socket = null;
   try {
    socket = serverSocket.accept();
    System.out.println("New connection accepted "+
      socket.getInetAddress()+":"+socket.getPort());
   } catch (IOException e) {
    e.printStackTrace();
   }finally{
    if(socket!=null){
     try {
      socket.close();
     } catch (IOException e) {
      e.printStackTrace();
     }
    }
   }
  }
 }
 
 public static void main(String[] args) throws Exception{
  Server server = new Server();
  Thread.sleep(60000*10);
  server.service();
 }
} 

      Client 试图与 Server 进行 100 次连接. 在 Server 类中, 把连接请求队列的长度设为 3. 这意味着当队列中有了 3 个连接请求时, 如果Client 再请求连接, 就会被 Server 拒绝.  下面按照以下步骤运行 Server 和 Client 程序.

 

      ⑴ 在Server 中只创建一个 ServerSocket 对象, 在构造方法中指定监听的端口为8000 和 连接请求队列的长度为 3 . 构造 Server 对象后, Server 程序睡眠 10 分钟, 并且在 Server 中不执行 serverSocket.accept() 方法. 这意味着队列中的连接请求永远不会被取出. 运行Server 程序和 Client 程序后, Client程序的打印结果如下:

 第 1 次连接成功
 第 2 次连接成功
 第 3 次连接成功
 Exception in thread "main" java.net.ConnectException: Connection refused: connect
 ................

      从以上打印的结果可以看出, Client 与 Server 在成功地建立了3 个连接后, 就无法再创建其余的连接了, 因为服务器的队已经满了.

 

      ⑵ 在Server中构造一个跟 ⑴ 相同的 ServerSocket对象, Server程序不睡眠, 在一个 while 循环中不断执行 serverSocket.accept()方法, 该方法从队列中取出连接请求, 使得队列能及时腾出空位, 以容纳新的连接请求. Client 程序的打印结果如下:

  第 1 次连接成功
  第 2 次连接成功
  第 3 次连接成功
  ...........
  第 100 次连接成功

      从以上打印结果可以看出, 此时 Client 能顺利与 Server 建立 100 次连接.(每次while的循环要够快才行, 如果太慢, 从队列取连接请求的速度比放连接请求的速度慢的话, 不一定都能成功连接) 

 

1.3 设定绑定的IP 地址

 

      如果主机只有一个IP 地址, 那么默认情况下, 服务器程序就与该IP 地址绑定. ServerSocket 的第 4 个构造方法 ServerSocket(int port, int backlog, InetAddress bingAddr) 有一个 bindAddr 参数, 它显式指定服务器要绑定的IP 地址, 该构造方法适用于具有多个IP 地址的主机. 假定一个主机有两个网卡, 一个网卡用于连接到 Internet, IP为 222.67.5.94, 还有一个网卡用于连接到本地局域网, IP 地址为 192.168.3.4. 如果服务器仅仅被本地局域网中的客户访问, 那么可以按如下方式创建 ServerSocket:

       ServerSocket serverSocket = new ServerSocket(8000, 10, InetAddress.getByName("192.168.3.4"));

 

1.4 默认构造方法的作用

 

      ServerSocket 有一个不带参数的默认构造方法. 通过该方法创建的 ServerSocket 不与任何端口绑定, 接下来还需要通过 bind() 方法与特定端口绑定.

      这个默认构造方法的用途是, 允许服务器在绑定到特定端口之前, 先设置ServerSocket 的一些选项. 因为一旦服务器与特定端口绑定, 有些选项就不能再改变了.

 

      在以下代码中, 先把 ServerSocket 的 SO_REUSEADDR 选项设为 true, 然后再把它与 8000 端口绑定:

  ServerSocket serverSocket = new ServerSocket();
  serverSocket.setReuseAddress(true);              //设置 ServerSocket 的选项
  serverSocket.bind(new InetSocketAddress(8000));  //与8000端口绑定

      如果把以上程序代码改为:

  ServerSocket serverSocket = new ServerSocket(8000);
  serverSocket.setReuseAddress(true);              //设置 ServerSocket 的选项

      那么 serverSocket.setReuseAddress(true) 方法就不起任何作用了, 因为 SO_REUSEADDR 选项必须在服务器绑定端口之前设置才有效.

 

二. 接收和关闭与客户的连接

 

      ServerSocket 的 accept() 方法从连接请求队列中取出一个客户的连接请求, 然后创建与客户连接的 Socket 对象, 并将它返回. 如果队列中没有连接请求, accept() 方法就会一直等待, 直到接收到了连接请求才返回.

 

      接下来, 服务器从 Socket 对象中获得输入流和输出流, 就能与客户交换数据. 当服务器正在进行发送数据的操作时, 如果客户端断开了连接, 那么服务器端会抛出一个IOException 的子类 SocketException 异常:

        java.net.SocketException: Connection reset by peer                                           

      这只是服务器与单个客户通信中出现的异常, 这种异常应该被捕获, 使得服务器能继续与其他客户通信.

 

      以下程序显示了单线程服务器采用的通信流程:

 

 public void service(){
  while(true){
   Socket socket = null;
   try{
       socket = serverSocket.accept();    //从连接请求队列中取出一个连接
    System.out.println("New connection accepted "
      + socket.getInetAddress()  + " : " + socket.getPort());
    //接收和发送数据
          ............
   }catch(IOException e)
     //这只是与单个客户通信时遇到的异常, 可能是由于客户端过早断开连接引起
     //这种异常不应该中断整个while循环
    e.printStackTrace();
   }finally{
    try{
     if(socket != null) socket.close();  //与一个客户通信结束后, 要关闭Socket
    }catch(IOException e){
     e.printStackTrace();}
   }
  }
 }

 

      与单个客户通信的代码放在一个try 代码块中, 如果遇到异常, 该异常被catch 代码块捕获. try 代码块后面还有一个finally 代码块, 它保证不管与客户通信正常结果还是异常结束, 最后都会关闭Socket, 断开与这个客户的连接.

 

三. 关闭ServerSocket

 

     ServerSocket 的 close() 方法使服务器释放占用的端口, 并且断开与所有客户的连接. 当一个服务器程序运行结束时, 即使没有执行 ServerSocket 的 close() 方法, 操作系统也会释放这个服务器占用的端口. 因此, 服务器程序不一定要在结束之前执行 ServerSocket 的 close() 方法.

 

      在某些情况下, 如果希望及时释放服务器的端口, 以便让其他程序能占用该端口, 则可以显式调用 ServerSocket 的 close() 方法. 例如, 以下代码用于扫描 1-65535 之间的端口号. 如果 ServerSocket 成功创建, 意味这该端口未被其他服务器进程绑定, 否则说明该端口已经被其他进程占用:

  for(int port = 1; port <= 65335; port ++){
   try{
    ServerSocket serverSocket = new ServerSocket(port);
    serverSocket.close();   //及时关闭ServerSocket
   }catch(IOException e){
    System.out.println("端口" + port + " 已经被其他服务器进程占用");
   }   
  }

 

     以上程序代码创建了一个 ServerSocket 对象后, 就马上关闭它, 以便及时释放它占用的端口, 从而避免程序临时占用系统的大多数端口.

 

     ServerSocket 的 isClosed() 方法判断 ServerSocket 是否关闭, 只有执行了 ServerSocket 的 close()方法, isClosed() 方法才返回 true; 否则, 即使 ServerSocket 还没有和特定端口绑定, isClosed() 也会返回 false.

 

      ServerSocket 的 isBound() 方法判断 ServerSocket 是否已经与一个端口绑定, 只要 ServerSocket 已经与一个端口绑定, 即使它已经被关闭, isBound() 方法也会返回 true.

 

      如果需要确定一个 ServerSocket 已经与特定端口绑定, 并且还没有被关闭, 则可以采用以下方式:

        boolean isOpen = serverSocket.isBound() && !serverSocket.isClosed();                             

 

四. 获取ServerSocket 的信息

 

     ServerSocket 的以下两个 get 方法可以分别获得服务器绑定的 IP 地址, 以及绑定的端口:

• public InetAddress getInetAddress();
• public int getLocalPort()

     前面已经讲到, 在构造 ServerSocket 时, 如果把端口设为 0 , 那么将有操作系统为服务器分配一个端口(称为匿名端口), 程序只要调用 getLocalPort() 方法就能获知这个端口号. 如下面的 RandomPort 创建了一个 ServerSocket, 它使用的就是匿名端口.

 

       RandomPort.java 

import java.net.ServerSocket;

public class RandomPort {

 public static void main(String[] args) throws Exception{
  ServerSocket serverSocket = new ServerSocket(0);
  System.out.println("监听的端口为："+serverSocket.getLocalPort());
 }
} 

      多数服务器会监听固定的端口, 这样才便于客户程序访问服务器. 匿名端口一般设用于服务器与客户之间的临时通信, 通信结束, 就断开连接, 并且 ServerSocket 占用的临时端口也被释放.

 

      FTP(文件传输协议) 就使用了匿名端口.  FTP协议用于在本地文件系统与远程文件系统之间传送文件.

 

      FTP 使用两个并行的TCP 连接: 一个是控制连接, 一个是数据连接. 控制连接用于在客户和服务器之间发送控制信息, 如用户名和口令、改变远程目录的命令或上传和下载文件的命令. 数据连接用于传送而文件. TCP 服务器在 21 端口上监听控制连接, 如果有客户要求上传或下载文件, 就另外建立一个数据连接, 通过它来传送文件. 数据连接的建立有两种方式.

 

      ⑴ TCP 服务器在 20 端口上监听数据连接, TCP 客户主动请求建立与该端口的连接.

 

      ⑵ 首先由 TCP 客户创建一个监听匿名端口的 ServerSocket, 再把这个 ServerSocket 监听的端口号发送给 TCP 服务器, 然后由TCP 服务器主动请求建立与客户端的连接.

 

      以上第二种方式就使用了匿名端口, 并且是在客户端使用的, 用于和服务器建立临时的数据连接. 在实际应用中, 在服务器端也可以使用匿名端口.

 

五. ServerSocket 选项

 

      ServerSocket 有以下 3 个选项.

• SO_TIMEOUT: 表示等待客户连接的超时时间.
• SO_REUSEADDR: 表示是否允许重用服务器所绑定的地址.
• SO_RCVBUF: 表示接收数据的缓冲区的大小.

5.1 SO_TIMEOUT 选项

• 设置该选项: public void setSoTimeout(int timeout) throws SocketException
• 读取该选项: public int getSoTimeout() throws SocketException

      SO_TIMEOUT 表示 ServerSocket 的 accept() 方法等待客户连接的超时时间, 以毫秒为单位. 如果SO_TIMEOUT 的值为 0 , 表示永远不会超时, 这是 SO_TIMEOUT 的默认值.

 

      当服务器执行 ServerSocket 的 accept() 方法是, 如果连接请求队列为空, 服务器就会一直等待, 直到接收到了客户连接才从 accept() 方法返回. 如果设定了超时时间, 那么当服务器等待的时间查欧哦了超时时间, 就会抛出 SocketTimeoutException, 它是 InterruptedException 的子类．

        java.net.SocketTimeoutException: Accept timed out                                                             

 

Tips: 服务器执行 serverSocket.accept() 方法时, 等待客户连接的过程也称为阻塞. 本书第 4 章的第一节详细介绍了阻塞的概念.

 

5.2 SO_REUSEADDR 选项

• 设置该选项: public void setResuseAddress(boolean on) throws SocketException
• 读取该选项: public boolean getResuseAddress() throws SocketException

      这个选项与Socket 的选项相同, 用于决定如果网络上仍然有数据向旧的 ServerSocket 传输数据, 是否允许新的 ServerSocket 绑定到与旧的 ServerSocket 同样的端口上. SO_REUSEADDR 选项的默认值与操作系统有关, 在某些操作系统中, 允许重用端口, 而在某些操作系统中不允许重用端口.

  

      当 ServerSocket 关闭时, 如果网络上还有发送到这个 ServerSocket 的数据, 这个ServerSocket 不会立即释放本地端口, 而是会等待一段时间, 确保接收到了网络上发送过来的延迟数据, 然后再释放端口.

 

      许多服务器程序都使用固定的端口. 当服务器程序关闭后, 有可能它的端口还会被占用一段时间, 如果此时立刻在同一个主机上重启服务器程序, 由于端口已经被占用, 使得服务器程序无法绑定到该端口, 服务器启动失败, 并抛出 BindException:

     java.net.BindExcetpion: Address already in use: JVM_Bind                                               

 

      为了确保一个进程关闭了 ServerSocket 后, 即使操作系统还没释放端口, 同一个主机上的其他进程还可以立即重用该端口, 可以调用 ServerSocket 的 setResuseAddress(true) 方法:

        if(!serverSocket.getReuseAddress()) serverSocket.setReuseAddress(true);                                  

 

      值得注意的是, serverSocket.setReuseAddress(true) 方法必须在 ServerSocket 还没有绑定到一个本地端口之前调用, 否则执行 serverSocket.setReuseAddress(true) 方法无效. 此外, 两个共用同一个端口的进程必须都调用 serverSocket.setResuseAddress(true) 方法, 才能使得一个进程关闭 ServerSocket 后, 另一个进程的 ServerSocket 还能够立刻重用相同的端口.

 

5.3 SO_RCVBUF 选项

• 设置该选项: public void setReceiveBufferSize(int size) throws SocketException
• 读取该选项: public int getReceiveBufferSize() throws SocketException

      SO_RCVBUF 表示服务器端的用于接收数据的缓冲区的大小, 以字节为单位. 一般说来, 传输大的连续的数据块(基于HTTP 或 FTP 协议的数据传输) 可以使用较大的缓冲区, 这可以减少传输数据的次数, 从而提高传输数据的效率. 而对于交互频繁且单次传送数量比较小的通信(Telnet 和 网络游戏), 则应该采用小的缓冲区, 确保能及时把小批量的数据发送给对方.

 

      SO_RCVBUF 的默认值与操作系统有关. 例如, 在Windows 2000 中运行以下代码时, 显示 SO_RCVBUF 的默认值为 8192.

 

      无论在 ServerSocket绑定到特定端口之前或之后, 调用 setReceiveBufferSize() 方法都有效. 例外情况下是如果要设置大于 64 KB 的缓冲区, 则必须在 ServerSocket 绑定到特定端口之前进行设置才有效.

 

      执行 serverSocket.setReceiveBufferSize() 方法, 相当于对所有由 serverSocket.accept() 方法返回的 Socket 设置接收数据的缓冲区的大小.

 

5.4 设定连接时间、延迟和带宽的相对重要性

• public void setPerformancePreferences(int connectionTime, int latency, int bandwidth)

     该方法的作用与 Socket 的 setPerformancePreferences 方法的作用相同, 用于设定连接时间、延迟和带宽的相对重要性, 参见 第二章的 5.10.

 

六. 创建多线程的服务器

 

      在第一章的 EchoServer中, 其 service()方法负责接收客户连接, 以及与客户通信. service() 方法的处理流程, EchoServer 接收到一个客户连接, 就与客户进行通信, 通信完毕后断开连接, 然后在接收下一个客户. 假如同时有多个客户请求连接, 这些客户就必须排队等候EchoServer 的响应. EchoServer 无法同时与多个客户通信.

 

      许多实际应用要求服务器具有同时为多个客户提供服务的能力. HTTP 服务器就是最明显的例子. 任何时刻, HTTP 服务器都可能接收到大量的客户请求, 每个客户都希望能快速得到HTTP 服务器的响应. 如果长时间让客户等待, 会使网站失去信誉, 从而降低访问量.

 

      可以用并发性能来衡量一个服务器同时响应多个客户的能力. 一个具有好的并发性能的服务器, 必须符合两个条件:

• 能同时接收并处理多个客户连接;
• 对于每个客户, 都会迅速给予响应.

     服务器同时处理的客户连接数目越多, 并且对每个客户作出响应的速度越快, 就表明并发性能越高.

 

     用多个线程来同时为多个客户提供服务, 这是提高服务器的并发性能的最常用的手段. 本结将按照 3 种方式来重新实现 EchoServer, 它们都使用了多线程.

• 为每个客户分配一个工作线程
• 创建一个线程池, 由其中的工作线程来为客户服务.
• 利用JDK 的 Java 类库中现成的线程池, 有它的工作线程来为客户服务.

6.1 为每个客户分配一个线程

 

      服务器的主线程负责接收客户的连接, 每次接收到一个客户连接, 就会创建一个工作线程, 由它负责与客户的通信. 以下是 EchoServer  的 service() 方法的代码:

 public void service(){
  while(true){
   Socket socket = null;
   try{
    socket = serverSocket.accept();           //接收客户连接
    Thread workThread = new Thread(new Handler(socket));         //创建一个工作进程
    workThread.start();        //启动工作进程
      }catch(IOException e){
       e.printStackTrace();
      }
  }
 }

 

      以上工作线程 workThread 执行 Handler 的 run() 方法. Handler 类实现了 Runnable 接口, 它的 run() 方法负责与单个客户通信, 与客户通信结束后, 就会断开连接, 执行 Handler 的 run() 方法的工作线程也会自然终止. 下面是 EchoServer 类及 Handler 类的源代码.

 

EchoServer.java(为每个任务分配一个线程)

package multithread1;

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.ServerSocket;
import java.net.Socket;

public class EchoServer {
 
 private int port = 8000;
 private ServerSocket serverSocket;
 
 public EchoServer() throws IOException{
  serverSocket = new ServerSocket(8000);
  System.out.println("服务器启动");
 }
 
 public void service(){
  while(true){
   Socket socket = null;
   try{
    socket = serverSocket.accept();           //接收客户连接
    Thread workThread = new Thread(new Handler(socket));         //创建一个工作进程
    workThread.start();        //启动工作进程
      }catch(IOException e){
       e.printStackTrace();
      }
  }
 }
 
 public static void main(String[] args) throws IOException {
  // TODO Auto-generated method stub
  new EchoServer().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() {
   // TODO Auto-generated method stub
   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){}
   }
  }
  
 }

} 

 

 6.2 创建线程池

   

      在 6.1 节介绍的实现方式中, 对每个客户都分配一个新的工作进程. 当工作线程与客户通信结束, 这个线程就被销毁. 这种实现方式有以下不足之处.

• 服务器创建和销毁工作线程的开销(包括所花费的时间和系统资源) 很大. 如果服务器需要与多个客户通信, 并且与每个客户的通信时间都很短, 那么有可能服务器为客户创建新线程的开销比实际与客户通信的开销还要大.
• 除了创建和销毁线程的开销之外, 活动的线程也消耗系统资源.每个线程本书都会占用一定的内存(每个线程需要大约 1MB 内存), 如果同时有大量客户连接服务器, 就必须创建大量工作线程, 它们消耗了大量内存, 可能会导致系统的内存空间不足.
• 如果线程数目固定, 并且每个线程都有很长的生命周期, 那么线程切换也是相对固定的. 不同的操作系统有不同的切换周期, 一般在 20 毫秒左右. 这里所说的线程切换是指在 Java 虚拟机, 以及底层操作系统的调度下, 线程之间转让 CPU 的使用权. 如果频繁创建和销毁进程, 那么将导致频繁地切换线程, 因为一个线程被销毁后, 必然要把 CPU 转让给另一个已经就绪的线程, 使该线程获得运行的机会. 在这种情况下, 线程之间不再遵循系统的固定切换周期, 切换进程的开销甚至比创建及销毁线程的开销还大.

      线程池为线程生命周期开销问题和系统资源不足问题提供了解决方案. 线程池中预先创建了一些工作线程, 它们不断从工作队列中取出任务, 然后执行该任务. 当工作线程执行完一个任务时, 就会继续执行工作队列中的下一个任务. 线程池具有以下的优点:

• 减少了创建和销毁线程的次数, 每个工作线程都可以一直被重用, 能执行多个任务.
• 可以根据系统的承载能力, 方便地调整线程池中线程的数目, 防止因为消耗过量系统资源而导致系统崩溃.

     下面的 ThreadPool 类提供了线程池的一种实现方案.

 

        ThreadPool.java

package multithread2;

import java.util.LinkedList;

public class ThreadPool extends ThreadGroup {
 private boolean isClosed = false;   //线程池是否关闭
 private LinkedList<Runnable> workQueue;  //工作队列
    private static int threadPoolID;   //表示线程池ID
    private int threadID;      //表示工作线程ID ,因为 WorkThread是内部类所以才可以这样
  

 public ThreadPool(int poolSize) {       //poolSize指定线程池中的工作线程数目
  super("ThreadPool-" + (threadPoolID ++));
  this.setDaemon(true);
  workQueue = new LinkedList<Runnable>();      //创建工作队列
  for(int i=0; i<poolSize; i++){
   new WorkThread().start();                //创建并启动工作进程
  }
 }
 public WorkThread getWorkThread(){
  return new WorkThread();
 }

 /**
  * 向工作队列中加入一个新任务, 由工作进程去执行该任务
  */
 public synchronized void execute(Runnable task){
  if(isClosed){              //线程池被关闭则抛出IllegalStateException 异常
   throw new IllegalStateException();
  }
  if(task != null){
   workQueue.add(task);      //添加任务到工作队列中
   notify();                 //呼醒正在getTask()方法中等待任务的某一个工作线程,哪一个是随机的
  }
 }
 
 /**
  * @throws InterruptedException wait()中被interrupt()将产生这个异常
  * 从工作队列中取出一个任务, 工作线程会调用此方法
  */
 protected synchronized Runnable getTask() throws InterruptedException{
  while(workQueue.size() == 0){
   if(isClosed) return null;
   wait();   //如果工作队列中没有任务, 就等待任务, 对应execute()方法中的notify和join()方法中的notifyAll()
  }
  return workQueue.removeFirst();
 }
 
 /** 关闭线程池 */
 public synchronized void close(){
  if(!isClosed){
   isClosed = true;
   workQueue.clear();    //清空工作队列
   interrupt();                 //中断所有的的工作线程, 该方法继承自 ThreadGroup 类
  }
 }
 
 /** 等待工作线程把所有任务执行完 */
 public void join(){
  synchronized(this){
   isClosed = true;
   notifyAll();            //呼醒所有在getTask()方法中等待任务的工作线程
  }
  Thread[] threads = new Thread[this.activeCount()];

  //enumerate()方法继承自 ThreadGroup 类, 获得线程组中当前所有活着的工作进程 ,并把这些线程放到指定的Thread数组中
  int count = this.enumerate(threads);
  for(int i=0; i<count; i++){         //等待所有工作线程运行结束
   try{
    threads[i].join();          //等待工作进程运行结束
   }catch(InterruptedException ex){}
  }
 } 
  
    /** 内部类: 工作线程(注意, 在本类中, 内部类(不是static的)和外部类可以互相访问对方的所有成员变量和方法, 即使是private的方法和成员变量,
     *                  本类内部访问限定符对内部类和外部类都没有影响, 就好像是在所有成员变量和方法视为一个同等的存在一样处理.
     *                  但是如果你是在其他类中就访问本类中的外部类和内部类的成员变量和方法, 那就会受到访问限定符的限制的.
     *                  最后还要注意, 不要在本类中的main() 中测试, 理由不用说了吧) */
 private class WorkThread extends Thread {
  public WorkThread() {
   // 加入到当前 ThreadPool 线程当中
   super(ThreadPool.this, "WorkThread-" + (threadID++));
  }

  public void run() {
   while(!isInterrupted()){       //isInterrupted() 方法继承自 Thread 类, 判断线程是否被中断
    Runnable task = null;
    try{
     task = getTask();   //取出任务
    }catch(InterruptedException e){}
    
    //如果getTask() 返回null, 表示线程池已经被关闭了, 结束此线程
    if(task == null) return;

    try{
     task.run();
    }catch(Throwable t){ //捕捉线程run()运行中产生所有的错误和异常,为了防止进程被结束
     t.printStackTrace();
    }

   }//while
  }//run
 }//WorkThread

}