第五十五篇： JAVA简易WEB服务器（五）

在之前的几篇博客中，我们的服务器已经具备雏形了，我们还需要继续对其进行优化，在《JAVA简易WEB服务器（三）》中，我们启动服务器的方法如下：

 /**  * 启动服务器  */ public synchronized void start() {    try    {       serverSocket = new ServerSocket(port);       LOG.info("server init success.");    }    catch (IOException e)    {       LOG.log(Level.SEVERE, e.getMessage(), e);    }    new Thread()    {       public void run()       {          while (!isStop())          {             Socket socket;             try             {                socket = serverSocket.accept();                handleRequest(socket);             }             catch (IOException e)             {                LOG.log(Level.SEVERE, e.getMessage(), e);             }          }       };    }.start(); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

我们是在一个线程中启动我们的服务器，避免阻塞主线程，但是这样，依然存在的问题是，我们的服务器一次只能处理一个请求，这样肯定是不合理的，所以在这一篇博客中，我们将使用多线程对服务端进行优化。

进一步的优化方式：使用多线程，我们可以在接收到请求后开辟新线程进行处理，代码如下：

/**  * 启动服务器  */ public synchronized void start2() {    try    {       serverSocket = new ServerSocket(port);       LOG.info("server init success.");    }    catch (IOException e)    {       LOG.log(Level.SEVERE, e.getMessage(), e);    }    new Thread()    {       public void run()       {          while (!isStop())          {              try             {                final Socket socket = serverSocket.accept();                new Thread()                {                   public void run()                   {                      try                      {                         handleRequest(socket);                      }                      catch (IOException e)                      {                        LOG.log(Level.SEVERE, e.getMessage(), e);                     }                  };               }.start();            }            catch (IOException e)            {               LOG.log(Level.SEVERE, e.getMessage(), e);            }         }      };   }.start();}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

这里，一旦TCP连接建立之后，将会创建一个新的线程来处理新的请求，在新的线程中执行handleRequest方法。 
通过创建新的线程，程序可以继续接受新的TCP连接，且这些请求可以并行的处理。 
在每个请求一个线程实现中，创建一个线程（和后续的销毁）开销是非常昂贵的，因为JVM和操作系统都需要分配资源。另外，上面的实现还有一个问题，即创建的线程数是不可控的，这将可能导致系统资源被迅速耗尽。 
所以我们应该继续寻找解决方案：线程池 
使用线程池可以更好的管理我们创建的线程，JDK为我们提供了几种默认的线程池实现，当线程池满后，后续的请求我们是用丢弃的策略，所以在这里面们使用自定义的线程池，完整的HQHttpServer代码如下：

package com.gujin.server;import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;import java.util.concurrent.ExecutorService;import java.util.concurrent.LinkedBlockingDeque;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;import java.util.logging.Level;import com.gujin.server.utils.HQClose;/** * 服务端 *  * @author jianggujin *  */public abstract class HQHttpServer implements HQHttpServerLog{   /** 端口号 **/   private int port = 80;   /** 服务套接字 **/   private ServerSocket serverSocket = null;   private int poolSize = 4;   private int capacity = 16;   /**    * 默认构造方法    */   public HQHttpServer()   {   }   /**    * 构造方法    *     * @param port    */   public HQHttpServer(int port)   {      this.port = port;   }   public int getPoolSize()   {      return poolSize;   }   public void setPoolSize(int poolSize)   {      this.poolSize = poolSize;   }   public int getCapacity()   {      return capacity;   }   public void setCapacity(int capacity)   {      this.capacity = capacity;   }   /**    * 异步启动服务器    */   public void startAsyn()   {      new Thread()      {         public void run()         {            start();         };      }.start();   }   /**    * 启动服务器    *     * @throws IOException    */   public synchronized void start() throws IOException   {      if (isStop())      {         serverSocket = new ServerSocket(port);         LOG.info("server init success.");         ExecutorService executorService = newBoundedFixedPool(poolSize,               poolSize);         while (!isStop())         {            Socket socket = serverSocket.accept();            LOG.info("accept client...");            executorService.submit(new HQSocketRunnable(socket));         }      }   }   /**    * 处理请求    *     * @param socket    * @throws IOException    */   protected void handleRequest(Socket socket) throws IOException   {      HQRequest request = new HQRequest(socket);      request.execute();      HQResponse response = new HQResponse(socket);      try      {         response.setCookieHandler(request.getCookieHandler().clone());      }      catch (CloneNotSupportedException e)      {         LOG.log(Level.SEVERE, e.getMessage(), e);      }      handleRequest(request, response);      response.response();      HQClose.safeClose(socket);   }   /**    * 处理请求    *     * @param request    * @param response    * @throws IOException    */   public abstract void handleRequest(HQRequest request, HQResponse response)         throws IOException;   /**    * 是否停止    *     * @return    */   public boolean isStop()   {      return serverSocket == null || serverSocket.isClosed();   }   /**    * 停止服务器    */   public synchronized void stop()   {      if (!isStop())      {         HQClose.safeClose(serverSocket);         serverSocket = null;      }   }   public static ExecutorService newBoundedFixedPool(int nThreads, int capacity)   {      return new ThreadPoolExecutor(nThreads, nThreads, 0L,            TimeUnit.MILLISECONDS, new LinkedBlockingDeque<Runnable>(capacity),            new ThreadPoolExecutor.DiscardPolicy());   }   private class HQSocketRunnable implements Runnable   {      private Socket socket = null;      public HQSocketRunnable(Socket socket)      {         this.socket = socket;      }      @Override      public void run()      {         try         {            handleRequest(socket);         }         catch (Exception e)         {            LOG.log(Level.SEVERE, e.getMessage(), e);         }      }   }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187