Java 网络编程 —— 创建多线程服务器

一个典型的单线程服务器示例如下：

1. while (true) {
2.     Socket socket = null;
3.     try {
4.         // 接收客户连接
5.         socket = serverSocket.accept();
6.         // 从socket中获得输入流与输出流，与客户通信
7.         ...
8.     } catch(IOException e) {
9.         e.printStackTrace()
10.     } finally {
11.         try {
12.             if(socket != null) {
13.                 // 断开连接
14.                 socket.close();
15.             } catch (IOException e) {
16.                 e.printStackTrace();
17.             }
18.         }
19.     }
20. }

复制代码

服务端接收到一个客户连接，就与客户进行通信，通信完毕后断开连接，然后接收下一个客户连接，假如同时有多个客户连接请求这些客户就必须排队等候。如果长时间让客户等待，就会使网站失去信誉，从而降低访问量。
一般用并发性能来衡量一个服务器同时响应多个客户的能力，一个具有好的并发性能的服务器，必须符合两个条件：

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

用多个线程来同时为多个客户提供服务，这是提高服务器并发性能的最常用的手段，一般有三种方式：

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

为每个客户分配一个线程

服务器的主线程负责接收客户的连接，每次接收到一个客户连接，都会创建一个工作线程，由它负责与客户的通信

1. public class EchoServer {
2.    
3.     private int port = 8000;
4.     private ServerSocket serverSocket;
5.    
6.     public EchoServer() throws IOException {
7.         serverSocket = new ServerSocket(port);
8.         System.out.println("服务器启动");
9.     }
10.         
11.     public void service() {
12.         while(true) {
13.             Socket socket = null;
14.             try {
15.                 // 接教客户连接
16.                 socket = serverSocket.accept();
17.                 // 创建一个工作线程
18.                 Thread workThread = new Thread(new Handler(socket));
19.                 // 启动工作线程
20.                 workThread.start();
21.             } catch (IOException e) {
22.                 e.printStackTrace();
23.             }
24.         }
25.     }
26.    
27.     public static void main(String args[])throws TOException {
28.         new EchoServer().service();
29.     }
30.    
31.     // 负责与单个客户的通信   
32.     class Handler implements Runnable {
33.         
34.         private Socket socket;
35.         
36.         pub1ic Handler(Socket socket) {
37.             this.socket = socket;
38.         }
39.         
40.         private PrintWriter getWriter(Socket socket) throws IOException {...}
41.         
42.         private BufferedReader getReader(Socket socket) throws IOException {...}
43.         
44.         public String echo(String msg) {...}
45.         
46.         public void run() {
47.             try {
48.                 System.out.println("New connection accepted" + socket.getInetAddress() + ":" + socket.getPort());
49.                 BufferedReader br = getReader(socket);
50.                 PrintWriter pw = getWriter(socket);
51.                
52.                 String msg = null;
53.                 // 接收和发送数据，直到通信结束
54.                 while ((msg = br.readLine()) != null) {
55.                     System.out.println("from "+ socket.getInetAddress() + ":" + socket.getPort() + ">" + msg);
56.                     pw.println(echo(msg));
57.                     if (msg.equals("bye")) break;
58.                 }
59.             } catch (IOException e) {
60.                 e.printStackTrace();
61.             } finally {
62.                 try {
63.                     // 断开连接
64.                     if(socket != nulll) socket.close();
65.                 } catch (IOException e) {
66.                     e,printStackTrace();
67.                 }
68.             }
69.         }
70.     }
71. }

复制代码

创建线程池

上一种实现方式有以下不足之处：

• 服务器创建和销毁工作线程的开销很大，如果服务器需要与许多客户通信，并且与每个客户的通信时间都很短，那么有可能服务器为客户创建新线程的开销比实际与客户通信的开销还要大
  
• 除了创建和销毁线程的开销，活动的线程也消耗系统资源。每个线程都会占用一定的内存，如果同时有大量客户连接服务器，就必须创建大量工作线程，它们消耗了大量内存，可能会导致系统的内存空间不足
  

线程池中预先创建了一些工作线程，它们不断地从工作队列中取出任务，然后执行该任务。当工作线程执行完一个任务，就会继续执行工作队列中的下一个任务
线程池具有以下优点：

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

1. public class ThreadPool extends ThreadGroup {
2.    
3.     // 线程池是否关闭
4.     private boolean isClosed = false;
5.     // 表示工作队列
6.     private LinkedList<Runnable> workQueue;
7.     // 表示线程池ID
8.     private static int threadPoolID;
9.     // 表示工作线程ID
10.    
11.     // poolSize 指定线程池中的工作线程数目
12.     public ThreadPool(int poolSize) {
13.         
14.         super("ThreadPool-"+ (threadPoolID++));
15.         setDaemon(true);
16.         // 创建工作队列
17.         workQueue = new LinkedList<Runnable>();
18.         for (int i = 0; i < poolSize; i++) {
19.             // 创建并启动工作线程
20.             new WorkThread().start();
21.         }
22.     }
23.    
24.     /**
25.      * 向工作队列中加入一个新任务，由工作线程去执行任务
26.      */
27.     public synchronized void execute(Runnable tank) {
28.         // 线程池被关则抛出IllegalStateException异常
29.         if(isClosed) {
30.             throw new IllegalStateException();
31.         }
32.         if(task != null) {
33.             workQueue.add(task);
34.             // 唤醒正在getTask()方法中等待任务的工作线限
35.             notify();
36.         }
37.     }
38.    
39.     /**
40.      * 从工作队列中取出一个任务，工作线程会调用此方法
41.      */
42.     protected synchronized Runnable getTask() throws InterruptedException {
43.         while(workQueue,size() == 0) {
44.             if (isClosed) return null;
45.             wait(); // 如果工作队列中没有任务，就等待任务
46.         }
47.         return workQueue.removeFirst();
48.     }
49.    
50.     /**
51.      * 关闭线程池
52.      */
53.     public synchronized void close() {
54.         if(!isClosed) {
55.             isClosed = true;
56.             // 清空工作队列
57.             workQueue.clear();
58.             // 中断所有的工作线程，该方法继承自ThreadGroup类
59.             interrupt();
60.         }
61.     }
62.    
63.     /**
64.      * 等待工作线程把所有任务执行完
65.      */
66.     public void join() {
67.         synchronized (this) {
68.             isClosed = true;
69.             // 唤醒还在getTask()方法中等待任务的工作线程
70.             notifyAll();
71.         }
72.         Thread[] threads = new Thread[activeCount()];
73.         // enumerate()方法继承自ThreadGroup类获得线程组中当前所有活着的工作线程
74.         int count = enumerate(threads);
75.         // 等待所有工作线程运行结束
76.         for(int i = 0; i < count; i++) {
77.             try {
78.                 // 等待工作线程运行结束
79.                 threads[i].join();
80.             } catch((InterruptedException ex) {}
81.         }
82.     }
83.    
84.     /**
85.      * 内部类:工作线程
86.      */
87.     private class WorkThread extends Thread {
88.            
89.         public WorkThread() {
90.             // 加入当前 ThreadPool 线程组
91.             super(ThreadPool.this, "WorkThread-" + (threadID++));
92.         }
93.         
94.         public void run() {
95.             // isInterrupted()方法承自Thread类，判断线程是否被中断
96.             while (!isInterrupted()) {
97.                 Runnable task = null;
98.                 try {
99.                     // 取出任务
100.                     task = getTask();
101.                 } catch(InterruptedException ex) {}
102.                 // 如果 getTask() 返回 nu11 或者线程执行 getTask() 时被中断，则结束此线程
103.                 if(task != null) return;
104.                 // 运行任务，异常在catch代码块中被捕获
105.                 try {
106.                     task.run();
107.                 } catch(Throwable t) {
108.                     t.printStackTrace();
109.                 }
110.             }
111.         }
112.     }
113. }

复制代码

使用线程池实现的服务器如下：

1. publlc class EchoServer {
2.    
3.     private int port = 8000;
4.     private ServerSocket serverSocket;
5.     private ThreadPool threadPool;        // 线程港
6.     private final int POOL_SIZE = 4;        // 单个CPU时线程池中工作线程的数目
7.    
8.     public EchoServer() throws IOException {
9.         serverSocket = new ServerSocket(port);
10.         // 创建线程池
11.         // Runtime 的 availableProcessors() 方法返回当前系统的CPU的数目
12.         // 系统的CPU越多，线程池中工作线程的数目也越多
13.         threadPool= new ThreadPool(
14.                 Runtime.getRuntime().availableProcessors() * POOL_SIZE);
15.         System.out.println("服务器启动");
16.     }
17.    
18.     public void service() {
19.         while (true) {
20.             Socket socket = null;
21.             try {
22.                 socket = serverSocket.accept();
23.                 // 把与客户通信的任务交给线程池
24.                 threadPool.execute(new Handler(socket));
25.             } catch(IOException e) {
26.                 e.printStackTrace();
27.             }
28.         }
29.     }
30.    
31.     public static void main(String args[])throws TOException {
32.         new EchoServer().service();
33.     }
34.    
35.     // 负责与单个客户的通信，与上例类似
36.     class Handler implements Runnable {...}
37. }

复制代码

使用 Java 提供的线程池

java.util.concurrent 包提供了现成的线程池的实现，更加健壮，功能也更强大，更多关于线程池的介绍可以这篇文章：

1. public class Echoserver {
2.    
3.     private int port = 8000;
4.     private ServerSocket serverSocket;
5.     // 线程池
6.     private ExecutorService executorService;
7.     // 单个CPU时线程池中工作线程的数目
8.     private final int POOL_SIZE = 4;
9.    
10.     public EchoServer() throws IOException {
11.         serverSocket = new ServerSocket(port);
12.         // 创建线程池
13.         // Runtime 的 availableProcessors() 方法返回当前系统的CPU的数目
14.         // 系统的CPU越多，线程池中工作线程的数目也越多
15.         executorService = Executors.newFixedThreadPool(
16.                 Runtime.getRuntime().availableProcessors() * POOL_SIZE);
17.         System.out.println("服务器启动");
18.     }
19.    
20.     public void service() {
21.         while(true) {
22.             Socket socket = null;
23.             try {
24.                 socket = serverSocket.accept();
25.                 executorService.execute(new Handler(socket));
26.             } catch(IOException e) {
27.                 e.printStackTrace();
28.             }
29.         }
30.     }
31.    
32.      public static void main(String args[])throws TOException {
33.         new EchoServer().service();
34.     }
35.    
36.     // 负责与单个客户的通信，与上例类似
37.     class Handler implements Runnable {...}
38. }

复制代码

使用线程池的注意事项

虽然线程池能大大提高服务器的并发性能，但使用它也存在一定风险，容易引发下面的问题：

• 死锁
  任何多线程应用程序都有死锁风险。造成死锁的最简单的情形是：线程 A 持有对象 X 的锁，并且在等待对象 Y 的锁，而线程 B 持有对象 Y 的锁，并且在等待对象 X 的锁，线程 A 与线程 B 都不释放自己持有的锁，并且等待对方的锁，这就导致两个线程永远等待下去，死锁就这样产生了
  任何多线程程序都有死锁的风险，但线程池还会导致另外一种死锁：假定线程池中的所有工作线程都在执行各自任务时被阻塞，它们都在等待某个任务 A 的执行结果。而任务 A 依然在工作队列中，由于没有空闲线程，使得任务 A 一直不能被执行。这使得线程池中的所有工作线程都永远阻塞下去，死锁就这样产生了
  
• 系统资源不足
  如果线程池中的线程数目非常多，这些线程就会消耗包括内存和其他系统资源在内的大量资源，从而严重影响系统性能
  
• 并发错误
  线程池的工作队列依靠 wait() 和 notify() 方法来使工作线程及时取得任务，但这两个方法都难以使用。如果编码不正确，就可能会丢失通知，导致工作线程一直保持空闲状态，无视工作队列中需要处理的任务
  
• 线程泄漏
  对于工作线程数目固定的线程池，如果工作线程在执行任务时抛出 RuntimeException 或 Error，并且这些异常或错误没有被捕获，那么这个工作线程就会异常终止，使得线程池永久地失去了一个工作线程。如果所有的工作线程都异常终止，线程池变为空，没有任何可用的工作线程来处理任务
  导致线程泄漏的另一种情形是，工作线程在执行一个任务时被阻塞，比如等待用户的输入数据，但是由于用户一直不输入数据（可能是因为用户走开了），导致这个工作线程一直被阻塞。这样的工作线程名存实亡，它实际上不执行任何任务了。假如线程池中所有的工作线程都处于这样的阻塞状态，那么线程池就无法处理新加入的任务了
  
• 任务过载
  当工作队列中有大量排队等候执行的任务，这些任务本身可能会消耗太多的系统资源而引起系统资源缺乏
  

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

• 如果任务 A 在执行过程中需要同步等待任务 B 的执行结果，那么任务 A 不适合加入线程池的工作队列中。如集把像任务 A 一样的需要等待其他任务执行结果的任务加入工作队列中，就可能会导致线程池的死锁
  
• 如果执行某个任务时可能会阻塞，并且是长时间的阻塞，则应该设定超时时间避免工作线程永久地阻塞下去而导致线程泄漏
  
• 了解任务的特点，分析任务是执行经常会阻塞的 IO 操作，还是执行一直不会阻塞的运算操作。前者时断时续地占用 CPU，而后者对 CPU 具有更高的利用率。根据任务的特点，对任务进行分类，然后把不同类型的任务分别加入不同线程池的工作队列中，这样可以根据任务的特点分别调整每个线程池
  
• 调整线程池的大小，线程池的最佳大小主要取决于系统的可用 CPU 的数目以及工作队列中任务的特点。假如在一个具有 N 个 CPU 的系统上只有一个工作队列并且其中全部是运算性质的任务，那么当线程池具有 N 或 N+1 个工作线程时，一般会获得最大的 CPU 利用率
  如果工作队列中包含会执行 IO 操作并经常阻塞的任务，则要让线程池的大小超过可用 CPU 的数目，因为并不是所有工作线程都一直在工作。选择一个典型的任务，然后估计在执行这个任务的过程中，等待时间（WT）与实际占用 CPU 进行运算的时间（ST）之间的比：WT/ST。对于一个具有 N 个 CPU 的系统，需要设置大约 N(1+WT/ST) 个线程来保证 CPU 得到充分利用
  
• 避免任务过载，服务器应根据系统的承受能力，限制客户的并发连接的数目。当客户的并发连接的数目超过了限制值，服务器可以拒绝连接请求，并给予客户友好提示
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！