Java网络编程精解之 - 多线程服务器

创建多线程的服务器

在本书第1章的1.5.1节的例程1-2的EchoServer中，其service()方法负责接收客户连接，以及与客户通信。service()方法的处理流程如下：

while (true) {
  Socket socket=null;
  try {
    socket = serverSocket.accept();     //接收客户连接
    //从Socket中获得输入流与输出流，与客户通信
    …
   
  }catch (IOException e) {
     e.printStackTrace();
  }finally {
     try{
if(socket!=null)socket.close();    //断开连接
     }catch (IOException e) {e.printStackTrace();}
  }
}


EchoServer接收到一个客户连接，就与客户进行通信，通信完毕后断开连接，然后再接收下一个客户连接。假如同时有多个客户请求连接，这些客户就必须排队等候EchoServer的响应。EchoServer无法同时与多个客户通信。

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

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

◆能同时接收并处理多个客户连接；

◆对于每个客户，都会迅速给予响应。

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

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

◆为每个客户分配一个工作线程。

◆创建一个线程池，由其中的工作线程来为客户服务。

◆利用JDK的Java类库中现成的线程池，由它的工作线程来为客户服务。

3.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()方法的工作线程也会自然终止。如例程3-5所示是EchoServer类及Handler类的源程序。

例程3-5  EchoServer.java（为每个任务分配一个线程）

package multithread1;
import java.io.*;
import java.net.*;
public class EchoServer {
  private int port=8000;
  private ServerSocket serverSocket;

  public EchoServer() throws IOException {
    serverSocket = new ServerSocket(port);
    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 {
    new EchoServer().service();
  }
}

class Handler implements Runnable{       //负责与单个客户的通信
  private Socket socket;
  public Handler(Socket socket){
    this.socket=socket;
  }
  private PrintWriter getWriter(Socket socket)throws IOException{…}
  private BufferedReader getReader(Socket socket)throws IOException{…}
  public String echo(String 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();}
    }
  }
}


#p#

3.6.2  创建线程池

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

◆服务器创建和销毁工作线程的开销（包括所花费的时间和系统资源）很大。如果服务器需要与许多客户通信，并且与每个客户的通信时间都很短，那么有可能服务器为客户创建新线程的开销比实际与客户通信的开销还要大。

◆除了创建和销毁线程的开销之外，活动的线程也消耗系统资源。每个线程本身都会占用一定的内存（每个线程需要大约1M内存），如果同时有大量客户连接服务器，就必须创建大量工作线程，它们消耗了大量内存，可能会导致系统的内存空间不足。

◆如果线程数目固定，并且每个线程都有很长的生命周期，那么线程切换也是相对固定的。不同操作系统有不同的切换周期，一般在20毫秒左右。这里所说的线程切换是指在Java虚拟机，以及底层操作系统的调度下，线程之间转让CPU的使用权。如果频繁创建和销毁线程，那么将导致频繁地切换线程，因为一个线程被销毁后，必然要把CPU转让给另一个已经就绪的线程，使该线程获得运行机会。在这种情况下，线程之间的切换不再遵循系统的固定切换周期，切换线程的开销甚至比创建及销毁线程的开销还大。

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

◆减少了创建和销毁线程的次数，每个工作线程都可以一直被重用，能执行多个任务。

◆可以根据系统的承载能力，方便地调整线程池中线程的数目，防止因为消耗过量系统资源而导致系统崩溃。

如例程3-6所示，ThreadPool类提供了线程池的一种实现方案。

例程3-6  ThreadPool.java

package multithread2;
import java.util.LinkedList;
public class ThreadPool extends ThreadGroup {
  private boolean isClosed=false;     //线程池是否关闭
  private LinkedList workQueue;   //表示工作队列
  private static int threadPoolID;     //表示线程池ID
  private int threadID;      //表示工作线程ID

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

/** 向工作队列中加入一个新任务，由工作线程去执行该任务 */
  public synchronized void execute(Runnable task) {
    if (isClosed) {      //线程池被关则抛出

IllegalStateException异常
      throw new IllegalStateException();
    }
    if (task != null) {
      workQueue.add(task);
      notify();       //唤醒正在getTask()方法中等待任务的工作线程
    }
  }

  /** 从工作队列中取出一个任务，工作线程会调用此方法 */
  protected synchronized Runnable getTask()throws InterruptedException{
    while (workQueue.size() == 0) {
      if (isClosed) return null;
      wait();       //如果工作队列中没有任务，就等待任务
    }
    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[activeCount()];
    //enumerate()方法继承自ThreadGroup类，获得线程组中当前所有活着的工作线程
    int count = enumerate(threads); 
    for (int i=0; i      try {
        threads[i].join();     //等待工作线程运行结束
      }catch(InterruptedException ex) { }
    }
  }

  /**  内部类：工作线程  */
  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 ex){}

        // 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
        if (task == null) return;
       
        try { //运行任务，异常在catch代码块中捕获
          task.run();
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }      //#while
    }       //#run()
  }       //#WorkThread类
}


在ThreadPool类中定义了一个LinkedList类型的workQueue成员变量，它表示工作队列，用来存放线程池要执行的任务，每个任务都是Runnable实例。ThreadPool类的客户程序（利用ThreadPool来执行任务的程序）只要调用ThreadPool类的execute (Runnable task)方法，就能向线程池提交任务。在ThreadPool类的execute()方法中，先判断线程池是否已经关闭。如果线程池已经关闭，就不再接收任务，否则就把任务加入到工作队列中，并且唤醒正在等待任务的工作线程。

#p#

在ThreadPool类的构造方法中，会创建并启动若干工作线程，工作线程的数目由构造方法的参数poolSize决定。WorkThread类表示工作线程，它是ThreadPool类的内部类。工作线程从工作队列中取出一个任务，接着执行该任务，然后再从工作队列中取出下一个任务并执行它，如此反复。

工作线程从工作队列中取任务的操作是由ThreadPool类的getTask()方法实现的，它的处理逻辑如下：

◆如果队列为空并且线程池已关闭，那就返回null，表示已经没有任务可以执行了；

◆如果队列为空并且线程池没有关闭，那就在此等待，直到其他线程将其唤醒或者中断；

◆如果队列中有任务，就取出第一个任务并将其返回。

线程池的join()和close()方法都可用来关闭线程池。join()方法确保在关闭线程池之前，工作线程把队列中的所有任务都执行完。而close()方法则立即清空队列，并且中断所有的工作线程。

ThreadPool类是ThreadGroup类的子类。ThreadGroup类表示线程组，它提供了一些管理线程组中线程的方法。例如，interrupt()方法相当于调用线程组中所有活着的线程的interrupt()方法。线程池中的所有工作线程都加入到当前ThreadPool对象表示的线程组中。ThreadPool类在close()方法中调用了interrupt()方法：

  /** 关闭线程池 */
  public synchronized void close() {
    if (!isClosed) {
      isClosed = true;
      workQueue.clear();   //清空工作队列
      interrupt();     //中断所有的工作线程，该方法继承自ThreadGroup类
    }
}


以上interrupt()方法用于中断所有的工作线程。interrupt()方法会对工作线程造成以下影响：

◆如果此时一个工作线程正在ThreadPool的getTask()方法中因为执行wait()方法而阻塞，则会抛出InterruptedException；

◆如果此时一个工作线程正在执行一个任务，并且这个任务不会被阻塞，那么这个工作线程会正常执行完任务，但是在执行下一轮while (!isInterrupted()) {…}循环时，由于isInterrupted()方法返回true，因此退出while循环。

如例程3-7所示，ThreadPoolTester类用于测试ThreadPool的用法。

例程3-7  ThreadPoolTester.java

package multithread2;
public class ThreadPoolTester {
  public static void main(String[] args) {
    if (args.length != 2) {
      System.out.println(
      "用法: java ThreadPoolTest numTasks poolSize");
      System.out.println(
      "  numTasks - integer: 任务的数目");
      System.out.println(
      "  numThreads - integer: 线程池中的线程数目");
      return;
    }
    int numTasks = Integer.parseInt(args[0]);
    int poolSize = Integer.parseInt(args[1]);

   ThreadPool threadPool = new ThreadPool(poolSize);    //创建线程池

    // 运行任务
    for (int i=0; i      threadPool.execute(createTask(i));

    threadPool.join();        //等待工作线程完成所有的任务
    // threadPool.close();       //关闭线程池
  }//#main()
 
  /**  定义了一个简单的任务(打印ID)   */
  private static Runnable createTask(final int taskID) {
    return new Runnable() {
      public void run() {
        System.out.println("Task " + taskID + ": start");
        try {
          Thread.sleep(500);       //增加执行一个任务的时间
        } catch (InterruptedException ex) { }
        System.out.println("Task " + taskID + ": end");
      }
    };
  }
}


ThreadPoolTester类的createTask()方法负责创建一个简单的任务。ThreadPoolTester类的main()方法读取用户从命令行输入的两个参数，它们分别表示任务的数目和工作线程的数目。main()方法接着创建线程池和任务，并且由线程池来执行这些任务，最后调用线程池的join()方法，等待线程池把所有的任务执行完毕。

运行命令“java multithread2.ThreadPoolTester 5 3”，线程池将创建3个工作线程，由它们执行5个任务。程序的打印结果如下：

Task 0: start
Task 1: start
Task 2: start
Task 0: end
Task 3: start
Task 1: end
Task 4: start
Task 2: end
Task 3: end
Task 4: end


从打印结果看出，主线程等到工作线程执行完所有任务后，才结束程序。如果把main()方法中的“threadPool.join()”改为“threadPool.close()”，再运行程序，则会看到，尽管有一些任务还没有执行，程序就运行结束了。

#p#

如例程3-8所示，EchoServer利用线程池ThreadPool来完成与客户的通信任务。

例程3-8  EchoServer.java（使用线程池ThreadPool类）

package multithread2;
import java.io.*;
import java.net.*;
public class EchoServer {
  private int port=8000;
  private ServerSocket serverSocket;
  private ThreadPool threadPool;      //线程池
  private final int POOL_SIZE=4;      //单个CPU时线程池中工作线程的数目

  public EchoServer() throws IOException {
    serverSocket = new ServerSocket(port);
    //创建线程池
    //Runtime的availableProcessors()方法返回当前系统的CPU的数目
    //系统的CPU越多，线程池中工作线程的数目也越多
    threadPool= new ThreadPool(
            Runtime.getRuntime().availableProcessors() * POOL_SIZE);

    System.out.println("服务器启动");
  }

  public void service() {
    while (true) {
      Socket socket=null;
      try {
        socket = serverSocket.accept();
        threadPool.execute(new Handler(socket));   //把与客户通信的任务交给线程池
      }catch (IOException e) {
         e.printStackTrace();
      }
    }
  }

  public static void main(String args[])throws IOException {
    new EchoServer().service();
  }
}

/** 负责与单个客户通信的任务，代码与3.6.1节的例程3-5的Handler类相同 */
class Handler implements Runnable{…} 


在以上EchoServer的service()方法中，每接收到一个客户连接，就向线程池ThreadPool提交一个与客户通信的任务。ThreadPool把任务加入到工作队列中，工作线程会在适当的时候从队列中取出这个任务并执行它。

3.6.3  使用JDK类库提供的线程池

java.util.concurrent包提供了现成的线程池的实现，它比3.6.2节介绍的线程池更加健壮，而且功能也更强大。如图3-4所示是线程池的类框图。



图3-4  JDK类库中的线程池的类框图

Executor接口表示线程池，它的execute(Runnable task)方法用来执行Runnable类型的任务。Executor的子接口ExecutorService中声明了管理线程池的一些方法，比如用于关闭线程池的shutdown()方法等。Executors类中包含一些静态方法，它们负责生成各种类型的线程池ExecutorService实例，如表3-1所示。

表3-1  Executors类生成的ExecutorService实例的静态方法

Executors类的静态方法
创建的ExecutorService线程池的类型
newCachedThreadPool()
在有任务时才创建新线程，空闲线程被保留60秒
newFixedThreadPool(int nThreads)
线程池中包含固定数目的线程，空闲线程会一直保留。参数nThreads设定线程池中线程的数目
newSingleThreadExecutor()
线程池中只有一个工作线程，它依次执行每个任务
newScheduledThreadPool(int corePoolSize)
线程池能按时间计划来执行任务，允许用户设定计划执行任务的时间。参数corePoolSize设定线程池中线程的最小数目。当任务较多时，线程池可能会创建更多的工作线程来执行任务
newSingleThreadScheduledExecutor()
线程池中只有一个工作线程，它能按时间计划来执行任务
如例程3-9所示，EchoServer就利用上述线程池来负责与客户通信的任务。

例程3-9  EchoServer.java（使用java.util.concurrent包中的线程池类）

package multithread3;
import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class EchoServer {
  private int port=8000;
  private ServerSocket serverSocket;
  private ExecutorService executorService;    //线程池
  private final int POOL_SIZE=4;      //单个CPU时线程池中工作线程的数目

  public EchoServer() throws IOException {
    serverSocket = new ServerSocket(port);
    //创建线程池
    //Runtime的availableProcessors()方法返回当前系统的CPU的数目
    //系统的CPU越多，线程池中工作线程的数目也越多
    executorService= Executors.newFixedThreadPool(
     Runtime.getRuntime().availableProcessors() * POOL_SIZE);

    System.out.println("服务器启动");
  }

  public void service() {
    while (true) {
      Socket socket=null;
      try {
        socket = serverSocket.accept();
        executorService.execute(new Handler(socket));
      }catch (IOException e) {
         e.printStackTrace();
      }
    }
  }

  public static void main(String args[])throws IOException {
    new EchoServer().service();
  }
}

/** 负责与单个客户通信的任务，代码与3.6.1节的例程3-5的Handler类相同 */
class Handler implements Runnable{…}


在EchoServer的构造方法中，调用Executors.newFixedThreadPool()创建了具有固定工作线程数目的线程池。在EchoServer的service()方法中，通过调用executor- Service.execute()方法，把与客户通信的任务交给了ExecutorService线程池来执行。

#p#

3.6.4  使用线程池的注意事项

虽然线程池能大大提高服务器的并发性能，但使用它也会存在一定风险。与所有多线程应用程序一样，用线程池构建的应用程序容易产生各种并发问题，如对共享资源的竞争和死锁。此外，如果线程池本身的实现不健壮，或者没有合理地使用线程池，还容易导致与线程池有关的死锁、系统资源不足和线程泄漏等问题。

1．死锁
任何多线程应用程序都有死锁风险。造成死锁的最简单的情形是，线程A持有对象X的锁，并且在等待对象Y的锁，而线程B持有对象Y的锁，并且在等待对象X的锁。线程A与线程B都不释放自己持有的锁，并且等待对方的锁，这就导致两个线程永远等待下去，死锁就这样产生了。

虽然任何多线程程序都有死锁的风险，但线程池还会导致另外一种死锁。在这种情形下，假定线程池中的所有工作线程都在执行各自任务时被阻塞，它们都在等待某个任务A的执行结果。而任务A依然在工作队列中，由于没有空闲线程，使得任务A一直不能被执行。这使得线程池中的所有工作线程都永远阻塞下去，死锁就这样产生了。

2．系统资源不足
如果线程池中的线程数目非常多，这些线程会消耗包括内存和其他系统资源在内的大量资源，从而严重影响系统性能。

3．并发错误
线程池的工作队列依靠wait()和notify()方法来使工作线程及时取得任务，但这两个方法都难于使用。

如果编码不正确，可能会丢失通知，导致工作线程一直保持空闲状态，无视工作队列中需要处理的任务。因此使用这些方法时，必须格外小心，即便是专家也可能在这方面出错。最好使用现有的、比较成熟的线程池。例如，直接使用java.util.concurrent包中的线程池类。

4．线程泄漏
使用线程池的一个严重风险是线程泄漏。对于工作线程数目固定的线程池，如果工作线程在执行任务时抛出RuntimeException 或Error，并且这些异常或错误没有被捕获，那么这个工作线程就会异常终止，使得线程池永久失去了一个工作线程。如果所有的工作线程都异常终止，线程池就最终变为空，没有任何可用的工作线程来处理任务。

导致线程泄漏的另一种情形是，工作线程在执行一个任务时被阻塞，如等待用户的输入数据，但是由于用户一直不输入数据（可能是因为用户走开了），导致这个工作线程一直被阻塞。这样的工作线程名存实亡，它实际上不执行任何任务了。假如线程池中所有的工作线程都处于这样的阻塞状态，那么线程池就无法处理新加入的任务了。

5．任务过载
当工作队列中有大量排队等候执行的任务时，这些任务本身可能会消耗太多的系统资源而引起系统资源缺乏。

综上所述，线程池可能会带来种种风险，为了尽可能避免它们，使用线程池时需要遵循以下原则。

（1）如果任务A在执行过程中需要同步等待任务B的执行结果，那么任务A不适合加入到线程池的工作队列中。如果把像任务A一样的需要等待其他任务执行结果的任务加入到工作队列中，可能会导致线程池的死锁。

（2）如果执行某个任务时可能会阻塞，并且是长时间的阻塞，则应该设定超时时间，避免工作线程永久的阻塞下去而导致线程泄漏。在服务器程序中，当线程等待客户连接，或者等待客户发送的数据时，都可能会阻塞。可以通过以下方式设定超时时间：

◆调用ServerSocket的setSoTimeout(int timeout)方法，设定等待客户连接的超时时间，参见本章3.5.1节（SO_TIMEOUT选项）；
◆对于每个与客户连接的Socket，调用该Socket的setSoTimeout(int timeout)方法，设定等待客户发送数据的超时时间，参见本书第2章的2.5.3节（SO_TIMEOUT选项）。

（3）了解任务的特点，分析任务是执行经常会阻塞的I/O操作，还是执行一直不会阻塞的运算操作。前者时断时续地占用CPU，而后者对CPU具有更高的利用率。预计完成任务大概需要多长时间？是短时间任务还是长时间任务？

根据任务的特点，对任务进行分类，然后把不同类型的任务分别加入到不同线程池的工作队列中，这样可以根据任务的特点，分别调整每个线程池。

（4）调整线程池的大小。线程池的最佳大小主要取决于系统的可用CPU的数目，以及工作队列中任务的特点。假如在一个具有 N 个CPU的系统上只有一个工作队列，并且其中全部是运算性质（不会阻塞）的任务，那么当线程池具有 N 或 N+1 个工作线程时，一般会获得最大的 CPU 利用率。

如果工作队列中包含会执行I/O操作并常常阻塞的任务，则要让线程池的大小超过可用CPU的数目，因为并不是所有工作线程都一直在工作。选择一个典型的任务，然后估计在执行这个任务的过程中，等待时间（WT）与实际占用CPU进行运算的时间（ST）之间的比例WT/ST。对于一个具有N个CPU的系统，需要设置大约N×(1+WT/ST)个线程来保证CPU得到充分利用。

当然，CPU利用率不是调整线程池大小过程中唯一要考虑的事项。随着线程池中工作线程数目的增长，还会碰到内存或者其他系统资源的限制，如套接字、打开的文件句柄或数据库连接数目等。要保证多线程消耗的系统资源在系统的承载范围之内。

（5）避免任务过载。服务器应根据系统的承载能力，限制客户并发连接的数目。当客户并发连接的数目超过了限制值，服务器可以拒绝连接请求，并友好地告知客户：服务器正忙，请稍后再试。