httpclient请求报 java.net.BindException: Address already in use

矫情吗；* 2022-06-05 10:41 137阅读 0赞

参考文档：

http://liuinsect.iteye.com/blog/1886237

http://www.iteye.com/topic/234759

http://blog.csdn.net/kobejayandy/article/details/16921265

### [HTTP Client MultiThreadedHttpConnectionManager线程安全连接管理类源码解析][HTTP Client MultiThreadedHttpConnectionManager] ###

为了更好的提供文章，我已经将博客迁移到了自建的博客网站上，我将更多的从源码分析的角度入手，为大家带来更多的深度文章，请大家继续关注我~！ 博客地址：[www.liuinsect.com][]

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_

MultiThreadedHttpConnectionManager 是HTTP Client中用来复用连接的连接管理类,可以通过

**Java代码 ![收藏代码][icon_star.png]**

1.  MultiThreadedHttpConnectionManager n = **new** MultiThreadedHttpConnectionManager(); 
2.  HttpClient client = **new** HttpClient(n);

这样的方式去 创建一个Client 实例，

创建后，每当执行

int statusCode = client.executeMethod(postMethod);时

http client 委托ConnectionManager创建连接，其实是先委托HttpMethodDirector 执行excute方法，

再通过它委托ConnectionManager 创建连接，HttpMethodDirector 中包含了一下host,请求参数等信息。

在创建连接时，HttpMethodDirector 中有如下代码：

**Java代码 ![收藏代码][icon_star.png]**

1.  **if** ( **this**.conn == **null**) \{ 
2.  **this**.conn = connectionManager.getConnectionWithTimeout( 
3.   hostConfiguration, 
4.  **this**.params.getConnectionManagerTimeout() 
5.   ); 
6.   ...... 
7.   \}

ConnectionManager 使用了常用的多态的方式将连接的获取交给子类完成。 增强其扩展性。

ConnectionManager 有三个子类：

![ab632cac-39f0-348a-a3be-0701a05b4d9b.png][]

对应于：

1. 一次性的连接：

![9cfed9b5-26af-3018-a9ad-7d97c959a3ba.png][]

2. 线程池中获取连接：

![69529ef4-dde5-3b2e-a3e9-aca64a25c49d.png][]

3. 复用当前SimpleHttpConnectionManager中的一个成员变量，策略是没有则创建，有则覆盖后返回

![62ef3d88-d5b5-3b02-b04f-c1d8f3fef1ce.png][]

**重点说下MultiThreadedHttpConnectionManager 中连接的获取****：**

在使用 MultiThreadedHttpConnectionManager 获取连接的时候，MultiThreadedHttpConnectionManager 使用了连接池的概念针对每个  
HostConfiguration 做了连接的管理，即 HostConfiguration 作为Key ，连接池（HostConnectionPool）作为value去管理当前host下的所有连接，  
HostConfiguration的实例如下： HostConfiguration\[host=http://www.taobao.com\]

HostConnectionPool 中使用**链表** 管理了 空闲的连接和等待连接的线程队列。

每次获取连接的时候 根据参数（后面会提到）决定是直接从池中获取一个空闲连接,创建一个连接，还是计算出一个等待时间后 将当前线程沉睡这么久。而后再检查。

Http Client 通过协议对应的ProtocolSocketFactory去创建一个socket连接来发送请求和接受响应

使用注意事项：

1. MultiThreadedHttpConnectionManager 中有以下两个变量，分别解释：

a. 每个host最大同时可以获取的连接数， 大于这个数字后， （1,2号线程正在使用连接）3号线程会wait 沉睡住 直到到达时间或者被打断或者1,2号中有人release这个connection，抛出异常。

注意，如果是HTTP client 来调用接口的话 这个例如（http://www.taobao.com 那他的host是www.taobao.com） 这个值应该设置大一点 否则很多线程调用这个接口的时候会阻塞住。

b. 同一时间MultiThreadedHttpConnectionManager 允许的最大连接数，超过这个数字，连接的建立将会阻塞。直到有空闲连接释放。

![e9cd0779-310e-3bcd-83ae-61ab59c6387b.png][]

使用注意事项测试代码： 下划线的两个方法可以调整后观察结果

**Java代码 ![收藏代码][icon_star.png]**

1.  **public** **static** **void** main(String\[\] sadfasd) **throws** HttpException, IOException, InterruptedException\{ 
2.  **final** String url= "http://www.taobao.com" ; 
3.  **final** HttpClient client = **new** HttpClient(); 
4.  **final** MultiThreadedHttpConnectionManager connectionManager = **new** MultiThreadedHttpConnectionManager(); 
5.   connectionManager.setMaxTotalConnections (1);//总的连接数
6.   connectionManager.setMaxConnectionsPerHost (2);//每个host的最大连接数
7.   client.setHttpConnectionManager( connectionManager ); 
8.  
9.   Runnable r = **new** Runnable()\{ 
10. **public** **void** run()\{ 
11. **int** statusCode=0; 
12.  PostMethod postMethod = **new** PostMethod(url); 
13. **try** \{ 
14.  statusCode = client.executeMethod(postMethod); 
15.  System. out.println( "sleep" \+ statusCode ); 
16.  Thread. sleep(3000);//10s
17.  postMethod.releaseConnection(); 
18.  \} **catch** (HttpException e) \{ 
19.  e.printStackTrace(); 
20.  \} **catch** (IOException e) \{ 
21.  e.printStackTrace(); 
22.  \} **catch** (InterruptedException e) \{ 
23.  e.printStackTrace(); 
24.  \} 
25.  \}; 
26.  \}; 
27.  Runnable r1 = **new** Runnable()\{ 
28. **public** **void** run()\{ 
29. **int** statusCode=0; 
30.  PostMethod postMethod = **new** PostMethod(url); 
31. **try** \{ 
32.  statusCode = client.executeMethod(postMethod); 
33.  \} **catch** (HttpException e) \{ 
34.  e.printStackTrace(); 
35.  \} **catch** (IOException e) \{ 
36.  e.printStackTrace(); 
37.  \} 
38.  System. out.println( statusCode ); 
39.  postMethod.releaseConnection(); 
40.  \}; 
41.  \}; 
42.  Runnable r2 = **new** Runnable()\{ 
43. **public** **void** run()\{ 
44. **int** statusCode=0; 
45.  PostMethod postMethod = **new** PostMethod(url); 
46. **try** \{ 
47.  statusCode = client.executeMethod(postMethod); 
48.  \} **catch** (HttpException e) \{ 
49.  e.printStackTrace(); 
50.  \} **catch** (IOException e) \{ 
51.  e.printStackTrace(); 
52.  \} 
53.  System. out.println( statusCode ); 
54.  postMethod.releaseConnection(); 
55.  \}; 
56.  \}; 
57.  Runnable r3 = **new** Runnable()\{ 
58. **public** **void** run()\{ 
59. **int** statusCode=0; 
60.  PostMethod postMethod = **new** PostMethod(url); 
61. **try** \{ 
62.  statusCode = client.executeMethod(postMethod); 
63.  \} **catch** (HttpException e) \{ 
64.  e.printStackTrace(); 
65.  \} **catch** (IOException e) \{ 
66.  e.printStackTrace(); 
67.  \} 
68.  System. out.println( statusCode ); 
69.  postMethod.releaseConnection(); 
70.  \}; 
71.  \}; 
72. **new** Thread(r).start(); 
73.  Thread. sleep(1000); 
74. **new** Thread(r1).start(); 
75. **new** Thread(r2).start(); 
76. **new** Thread(r3).start(); 
77. 
78.  \}

**释放连接：**

在我们调用postMethod.releaseConnection()时， 会调用connectionManager的releaseConnection方法。  
注意：进入这个方法后会首先同步整个connectionPool（连接池）对象，这意味着，在多连接复用的时候频繁的释放连接，也是会有性能损耗的，同步整个connectionPool后连接的创建都会受影响。  
然后开始归还连接，归还的方式很清晰：

1. 将Connection放到基于host的连接池的空闲链表中  
hostPool. freeConnections .add(conn);  
2.将Connection放到整个全局的connectionPool的空闲链表中  
3. 将Connection从Reference Map中移除（Reference Map 后面单独讲解）  
4. 将Connection加入到超时管理中去。  
5. 将hostPool（host连接池）里等待队列的头元素拿出来 发送interrupt的信号量。目的是 唤醒等待连接的线程。

到目前为止，有两个点可以详细说下  
1. Reference Map的作用。  
2. 等待连接的线程的处理方式。

首先说**Reference Map**,这个名字是我自己取的。它在MultiThreadedHttpConnectionManager 中的名字叫做：

![d20fbff5-c6a0-3a3c-8421-bb79be056176.png][]

在每次获取连接和释放连接的时候会将”连接“存入和移除。

**注意： 这里的”连接“ 已经不是Connection 而是用 WeakReference包装过的Connection。**

为什么用WeakReference？

这里的概念和ThreadLocal 中用WeakReference 包装ThreadLocalMap中的Key一样。

目的是为了 在连接丢失时，HTTP client 失去了对“连接”（Connection）的强引用，该连接对象变成了弱引用对象，可以被GC掉。

所以，每次在获取连接的时候 要将连接用WeakReference 包装后放到*REFERENCE\_TO\_CONNECTION\_SOURCE* 这个Map中,

每次释放连接时，将它从*REFERENCE\_TO\_CONNECTION\_SOURCE* 中移除,因为这个时候连接的管理由线程池使用强引用管理。

再说，**等待连接的线程的处理方式**

先看 **获取连接时的代码 和注释** 大部分代码被精简了。 所以逻辑不通，看流程即可。

**Java代码 ![收藏代码][icon_star.png]**

1.  **synchronized** (connectionPool) \{ 
2.  **while** (connection == **null**) \{ 
3.  **if** (hostPool.freeConnections.size() > 0) \{ 
4.  //有线程池中有空闲的连接
5.   connection = connectionPool.getFreeConnection(hostConfiguration); 
6.  
7.   \} **else** **if** ((hostPool.numConnections < maxHostConnections) && (connectionPool.numConnections < maxTotalConnections)) \{ 
8.  //没有空闲连接，但是满足前文的两个条件 可以创建新的连接
9.   connection = connectionPool.createConnection(hostConfiguration); 
10. 
11.  \} **else** **if** ((hostPool.numConnections < maxHostConnections) && (connectionPool.freeConnections.size() > 0)) \{ 
12. 
13. //整个连接数 没有到达最大，并且有空闲连接（其他host池中） 则删除掉其他host中的连接，并且在当前host池子中创建新连接
14.  connectionPool.deleteLeastUsedConnection(); 
15.  connection = connectionPool.createConnection(hostConfiguration); 
16.  \} **else** \{ 
17. //以上条件都不满足， 只能将当前线程睡眠
18. **try** \{ 
19.  waitingThread = **new** WaitingThread();//创建一个线程包装类
20.  waitingThread.hostConnectionPool = hostPool;//指定所属的host连接池
21.  waitingThread.thread = Thread.currentThread();//将当前线程赋值 
22.  startWait = System.currentTimeMillis (); 
23. 
24.  hostPool.waitingThreads.addLast(waitingThread);//将线程包装类 添加到host连接池的 等待列表中
25.  connectionPool.waitingThreads.addLast(waitingThread);//将线程包装类 添加到全局连接池的 等待列表中
26.  connectionPool.wait(timeToWait);//沉睡
27.  \} **catch** (InterruptedException e) \{ 
28. //被打断是检查 布尔变量interruptedByConnectionPool 确定是 HTTP 释放连接后 主动打断的，还是其他异常原因打断
29. //是自己打断的 catch住异常后什么也不做，重新进入while循环中，尝试获取连接
30. **if** (!waitingThread.interruptedByConnectionPool) \{ 
31. **throw** **new** IllegalThreadStateException("Interrupted while waiting in MultiThreadedHttpConnectionManager"); 
32.  \} 
33.  \} **finally** \{ 
34. **if** (!waitingThread.interruptedByConnectionPool) \{ 
35.  hostPool.waitingThreads.remove(waitingThread); 
36.  connectionPool.waitingThreads.remove(waitingThread); 
37.  \} 
38. **if** (useTimeout) \{ 
39.  endWait = System.currentTimeMillis (); 
40.  timeToWait -= (endWait - startWait); 
41.  \} 
42.  \} 
43.  \} 
44.  \} 
45.  \}

**释放连接时**

调用notifyWaitingThread 方法，结合上面的代码看：

**Java代码 ![收藏代码][icon_star.png]**

1.  **public** **synchronized** **void** notifyWaitingThread(HostConnectionPool hostPool) \{ 
2.  
3.  // find the thread we are going to notify, we want to ensure that each
4.  // waiting thread is only interrupted once so we will remove it from
5.  // all wait queues before interrupting it
6.   WaitingThread waitingThread = **null**; 
7.  // 取出 等待的线程后发送 interrupt 信号量，
8.  
9.  **if** (hostPool.waitingThreads.size() > 0) \{ 
10. 
11.  waitingThread = ( WaitingThread) hostPool.waitingThreads.removeFirst(); 
12.  waitingThreads.remove(waitingThread); 
13.  \} **else** **if** (waitingThreads .size() > 0) \{ 
14. 
15.  waitingThread = ( WaitingThread) waitingThreads.removeFirst(); 
16.  waitingThread.hostConnectionPool.waitingThreads.remove(waitingThread); 
17.  \} 
18. // 导致 获取连接的那个方法中 捕获异常
19. // 注：interrupt 信号量是一定会引起 interruptException的
20. // 将interruptedByConnectionPool 设置为true 好标明 是 HTTP client 手动打断的。 这是HTTP client对于等待线程唤醒方式的核心思路
21. **if** (waitingThread != **null**) \{ 
22.  waitingThread.interruptedByConnectionPool = **true**; 
23.  waitingThread.thread.interrupt(); 
24.  \} 
25.  \}

上面两端代码主要思路就是: 有空连接就直接用，没有则沉睡等待唤醒。

其实用interrupt信号量 会引起interruptException异常，通过catch住异常来处理，是比较粗暴的。

优雅的用 wait and notify的方式 就不需要catch异常，同样能达到唤醒线程效果，而且很优雅。

**MultiThreadedHttpConnectionManager** **中对弱引用的使用**

MultiThreadedHttpConnectionManager 类中 还有一个 ReferenceQueueThread类 是用来配合HttpConnectionWithReference（将连接用弱引用包裹后的对象）使用的

![d18cec7b-bd12-3c3e-932a-ca98b0233a52.png][]

使用的方式是这样：

1. 创建连接时，用弱引用包裹住Connection对象放到*REFERENCE\_TO\_CONNECTION\_SOURCE* 中，目的是防止在连接丢失的时候Map中的这个HttpConnectionWithReference 对象变成弱引用，

在GC回收时会被回收掉，防止内存泄露。

2. 首先明确的是，JVM会在HttpConnectionWithReference 被回收的时候，将他加入到REFERENCE\_QUEUE 中。这是JAVA对于弱引用的规则。

3. 同时，在将HttpConnectionWithReference 放入Map时，启动一个子线程 ReferenceQueueThread 去监听 这个REFERENCE\_QUEUE ，只要这个REFERENCE\_QUEUE 有值（被GC回收的时候）

立马被取出来，将线程池可用连接的大小 -1 。

MultiThreadedHttpConnectionManager 使用弱引用 确保了

1. connection对象丢失时 内存的及时回收。

2. 搭配队列和子线程确保，连接丢失后线程池中可用连接数的次数可以修改。

说到这里，HTTP Client的MultiThreadedHttpConnectionManager 类的绝大部分分方法已经解释完毕了。其中主要是省略掉了，发送和读取HTTP 报文的代码，没有太多技巧，以规则解析出来即可。

**总结：**

1. 在单纯的发送请求的场景下，使用MultiThreadedHttpConnectionManager 来代替SimpleHTTPConnectionManger是可行的，并且MultiThreadedHttpConnectionManager 的连接池机制也会提高发送请求的效率，

2. 但是觉得不符合分布式应用间的借口调用，原因很简单，对每个host做了连接池，在一定情况下，这个限制是致命的，直接影响了接口的调用效率。严重影响调用的并发数。所以，在分布式应用的调用中不适合使用MultiThreadedHttpConnectionManager 。

**MultiThreadedHttpConnectionManager****类中几个值得注意的点：**

**1.** **连接的管理，特别是使用WeakReference包装Connection对象，然后结合一个子线程和Queque去确保对象被回收时，可以连接数的增加。**

**2.** **对于没有连接可用时，使用使当前线程睡眠的，在释放连接时 使用** **interrupt****信号量 是等待线程恢复的处理方式**

Java代码

![收藏代码][icon_star.png 1]

1.  HttpClient client = new HttpClient();
2.  HttpMethod method = new GetMethod("http://www.apache.org");
3.  try \{
4.  client.executeMethod(method);
5.  byte\[\] responseBody = null;
6.  
7.  responseBody = method.getResponseBody();
8.  
9.  \} catch (HttpException e) \{
10. // TODO Auto-generated catch block
11. e.printStackTrace();
12. \} catch (IOException e) \{
13. // TODO Auto-generated catch block
14. e.printStackTrace();
15. \}finally\{
16. method.releaseConnection();
17. 
18. \}

大部分人使用HttpClient都是使用类似上面的事例代码，包括Apache官方的例子也是如此。最近我在使用HttpClient是发现一次循环发送大量请求到服务器会导致APACHE服务器的链接被占满，后续的请求便排队等待。  
我服务器端APACHE的配置

Java代码

![收藏代码][icon_star.png 1]

1.  Timeout 30
2.  KeepAlive On \#表示服务器端不会主动关闭链接
3.  MaxKeepAliveRequests 100
4.  KeepAliveTimeout 180

因此这样的配置就会导致每个链接至少要过180S才会被释放，这样在大量请求访问时就必然会造成链接被占满，请求等待的情况。  
在通过DEBUH后发现HttpClient在method.releaseConnection()后并没有把链接关闭，这个方法只是将链接返回给connection manager。如果使用HttpClient client = new HttpClient()实例化一个HttpClient connection manager默认实现是使用SimpleHttpConnectionManager。SimpleHttpConnectionManager有个构造函数如下

Java代码

![收藏代码][icon_star.png 1]

1.  /\*\*
2.  \* The connection manager created with this constructor will try to keep the
3.  \* connection open (alive) between consecutive requests if the alwaysClose
4.  \* parameter is set to <tt>false</tt>. Otherwise the connection manager will
5.  \* always close connections upon release.
6.  \*
7.  \* @param alwaysClose if set <tt>true</tt>, the connection manager will always
8.  \* close connections upon release.
9.  \*/
10. public SimpleHttpConnectionManager(boolean alwaysClose) \{
11. super();
12. this.alwaysClose = alwaysClose;
13. \}

看方法注释我们就可以看到如果alwaysClose设为true在链接释放之后connection manager 就会关闭链。在我们HttpClient client = new HttpClient()这样实例化一个client时connection manager是这样被实例化的

Java代码

![收藏代码][icon_star.png 1]

1.  this.httpConnectionManager = new SimpleHttpConnectionManager();

因此alwaysClose默认是false,connection是不会被主动关闭的，因此我们就有了一个客户端关闭链接的方法。  
**方法一：**  
把事例代码中的第一行实例化代码改为如下即可，在method.releaseConnection();之后connection manager会关闭connection 。

Java代码

![收藏代码][icon_star.png 1]

1.  HttpClient client = new HttpClient(new HttpClientParams(),new SimpleHttpConnectionManager(true) );

**方法二：**  
实例化代码使用：HttpClient client = new HttpClient();  
在method.releaseConnection();之后加上

Java代码

![收藏代码][icon_star.png 1]

1.  ((SimpleHttpConnectionManager)client.getHttpConnectionManager()).shutdown();

shutdown源代码很简单，看了一目了然

Java代码

![收藏代码][icon_star.png 1]

1.  public void shutdown() \{
2.  httpConnection.close();
3.  \}

**方法三：**  
实例化代码使用：HttpClient client = new HttpClient();  
在method.releaseConnection();之后加上  
client.getHttpConnectionManager().closeIdleConnections(0);此方法源码代码如下：

Java代码

![收藏代码][icon_star.png 1]

1.  public void closeIdleConnections(long idleTimeout) \{
2.  long maxIdleTime = System.currentTimeMillis() - idleTimeout;
3.  if (idleStartTime <= maxIdleTime) \{
4.  httpConnection.close();
5.  \}
6.  \}

将idleTimeout设为0可以确保链接被关闭。  
以上这三种方法都是有客户端主动关闭TCP链接的方法。下面再介绍由服务器端自动关闭链接的方法。  
**方法四：**  
代码实现很简单，所有代码就和最上面的事例代码一样。只需要在HttpMethod method = new GetMethod("http://www.apache.org");加上一行HTTP头的设置即可

Java代码

![收藏代码][icon_star.png 1]

1.  method.setRequestHeader("Connection", "close");

看一下HTTP协议中关于这个属性的定义：  
HTTP/1.1 defines the "close" connection option for the sender to signal that the connection will be closed after completion of the response. For example,  
Connection: close  
现在再说一下客户端关闭链接和服务器端关闭链接的区别。如果采用客户端关闭链接的方法，在客户端的机器上使用netstat –an命令会看到很多TIME\_WAIT的TCP链接。如果服务器端主动关闭链接这中情况就出现在服务器端。  
参考WIKI上的说明http://wiki.apache.org/HttpComponents/FrequentlyAskedConnectionManagementQuestions  
The TIME\_WAIT state is a protection mechanism in TCP. The side that closes a socket connection orderly will keep the connection in state TIME\_WAIT for some time, typically between 1 and 4 minutes.  
TIME\_WAIT的状态会出现在主动关闭链接的这一端。TCP协议中TIME\_WAIT状态主要是为了保证数据的完整传输。具体可以参考此文档：  
http://www.softlab.ntua.gr/facilities/documentation/unix/unix-socket-faq/unix-socket-faq-2.html\#ss2.7  
**另外强调一下使用上面这些方法关闭链接是在我们的应用中明确知道不需要重用链接时可以主动关闭链接来释放资源。如果你的应用是需要重用链接的话就没必要这么做，使用原有的链接还可以提供性能。**

方法二：  
实例化代码使用：HttpClient client = new HttpClient();  
在method.releaseConnection();之后加上  
Java代码  
((SimpleHttpConnectionManager)client.getHttpConnectionManager()).shutdown();  
  
((SimpleHttpConnectionManager)client.getHttpConnectionManager()).shutdown();  
shutdown源代码很简单，看了一目了然  
Java代码  
public void shutdown() \{  
httpConnection.close();  
\}  
  
public void shutdown() \{  
httpConnection.close();  
\}  
  
方法二中的httpConnection.close();这里没有参数么?  
httpConnection为默认全局的那个连接?

HttpClient client = new HttpClient(); 如果这样进行实例化，默认使用SimpleHttpConnectionManager作为connection manager，SimpleHttpConnectionManager没有连接池，只管理一个连接

**建立连接**

在HttpClient中使用多线程的一个主要原因是可以一次执行多个方法。在执行期间，每一个方法都使用一个HttpConnection实例。由于在同一时间多个连接只能安全地用于单一线程和方法和有限的资源，我们就必须确保连接分配给正确的方法。而MultiThreadedHttpConnectionManager完全可以代替我们完成这一项工作，这样我们就不必去考虑多线程带来安全的问题。  
MultiThreadedHttpConnectionManager connectionManager =  
new MultiThreadedHttpConnectionManager();  
HttpClient client = new HttpClient(connectionManager);

以上代码中的HttpClient就在多线程中执行多个方法了。当我们再次调用httpClient.executeMethod()方法时，就会去Connection Manager中去请求HttpConneciton的实例，这样就避免了线程安全问题，因为HttpClient已经帮我们做了。

**释放连接**

Connection Management比较重要的是当连接不再使用时，一定要手动释放。这样做的原因是HttpClient不能够确定哪个方法不被使用，哪个方法还在使用。这是因为Response body不是由HttpClient来自动读取其数据的，而是由使用HttpClient的应用程序来完成的。当读取Response的数据是时，必须使用此方法的连接。这样，在Response的数据在读取前，HttpClient是没有释放连接的。所有这就要求在读取完Response的数据后，应用程序及时的使用releaseConnection（）方法来释放连接。特别注意，无论执行的方法或是否也不例外被抛出。对于每一个HttpClient.executeMethod方法必须有一个method.releaseConnection （ ）来释放连接。

**重用HttpClient实例**

一般说来，建议一个通讯组件，甚至说一个应用软件就始终维持一个HttpClient对象实例存在。但是如果你的应用很稀罕才用到它，而且还不允许这么一个实例一直存在，那么，这里强烈建议，一定要显式地shut down 它的MultiThreadedHttpConnectionManager 。这样做是确保连接池里的Connection得到释放。

**HttpMethod并发执行**

如果应用程序逻辑允许并发执行多个HTTP请求，（例如对多个服务器的多个并发请求，或对同一个服务器代表不同用户身份的多个请求） ，应用程序可以为每一个HTTP session开启一个专门的线程，这样的设计自然将带来显著的性能提升。 而当使用一个线程安全的连接管理器MultiThreadedHttpConnectionManager 时，HttpClient能保证线程安全。这样，多个线程可以共享这么一个线程安全的HttpClient实例。请注意，应用程序的每个各自执行的线程必须使用各自的HttpMethod实例；并且可配置各自的HttpState实例和/或HostConfiguration实例（代表一个特定的会话状态和主机配置）。这个共享的HttpClient和其标配的MultiThreadedHttpConnectionManager将为各线程带来最高的性能。

**使用流来发送和接收数据**

HttpClient同时支持Stream和String/byte\[\]两种方式来发送和接受数据，但是由于String/byte\[\]的方式会造成内存中有一份数据的拷贝或缓存，那么当请求或应答报文比较大，或者在高并发的应用中，使用String/byte\[\]就会造成额外的内存开销，所以使用流的方式来传输数据是更好的选择。

**HttpClient的三种超时说明**

/\* 从连接池中取连接的超时时间 \*/  
ConnManagerParams.setTimeout(params, 1000);  
/\* 连接超时 \*/  
HttpConnectionParams.setConnectionTimeout(params, 2000);  
/\* 请求超时 \*/  
HttpConnectionParams.setSoTimeout(params, 4000);  
  
第一行设置ConnectionPoolTimeout：这定义了从ConnectionManager管理的连接池中取出连接的超时时间，此处设置为1秒。  
第二行设置ConnectionTimeout：　　这定义了通过网络与服务器建立连接的超时时间。Httpclient包中通过一个异步线程去创建与服务器的socket连接，这就是该socket连接的超时时间，此处设置为2秒。  
第三行设置SocketTimeout：　　　　这定义了Socket读数据的超时时间，即从服务器获取响应数据需要等待的时间，此处设置为4秒。  
以上3种超时分别会抛出ConnectionPoolTimeoutException,ConnectionTimeoutException与SocketTimeoutException。

[HTTP Client MultiThreadedHttpConnectionManager]: http://liuinsect.iteye.com/blog/1886237
[www.liuinsect.com]: http://www.liuinsect.com/
[icon_star.png]: /images/20220605/e968ab3bf12b47e0aa4cd89998fc920a.png
[ab632cac-39f0-348a-a3be-0701a05b4d9b.png]: http://dl2.iteye.com/upload/attachment/0085/7120/ab632cac-39f0-348a-a3be-0701a05b4d9b.png
[9cfed9b5-26af-3018-a9ad-7d97c959a3ba.png]: http://dl2.iteye.com/upload/attachment/0085/7122/9cfed9b5-26af-3018-a9ad-7d97c959a3ba.png
[69529ef4-dde5-3b2e-a3e9-aca64a25c49d.png]: http://dl2.iteye.com/upload/attachment/0085/7124/69529ef4-dde5-3b2e-a3e9-aca64a25c49d.png
[62ef3d88-d5b5-3b02-b04f-c1d8f3fef1ce.png]: http://dl2.iteye.com/upload/attachment/0085/7126/62ef3d88-d5b5-3b02-b04f-c1d8f3fef1ce.png
[e9cd0779-310e-3bcd-83ae-61ab59c6387b.png]: http://dl2.iteye.com/upload/attachment/0085/7128/e9cd0779-310e-3bcd-83ae-61ab59c6387b.png
[d20fbff5-c6a0-3a3c-8421-bb79be056176.png]: http://dl2.iteye.com/upload/attachment/0085/7130/d20fbff5-c6a0-3a3c-8421-bb79be056176.png
[d18cec7b-bd12-3c3e-932a-ca98b0233a52.png]: http://dl2.iteye.com/upload/attachment/0085/7132/d18cec7b-bd12-3c3e-932a-ca98b0233a52.png
[icon_star.png 1]: /images/20220605/a6dcb540dbbc46d4a6856615753f4dc8.png