httpClient多线程请求

最新推荐文章于 2022-02-22 14:03:49 发布
最新推荐文章于 2022-02-22 14:03:49 发布
阅读量1k 收藏 1
点赞数


使用httpClient可模拟请求Url获取资源，使用单线程的请求速度上会有一定的限制，参考了Apache给出的例子，自己做了测试实现多线程并发请求，以下代码需要HttpClient 4.2的包，可以在http://hc.apache.org/downloads.cgi下载

package generate.httpclient;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.PoolingClientConnectionManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;

public class ThreadPoolHttpClient {
    // 线程池
    private ExecutorService exe = null;
    // 线程池的容量
    private static final int POOL_SIZE = 20;
    private HttpClient client = null;
    String[] urls=null;
    public ThreadPoolHttpClient(String[] urls){
        this.urls=urls;
    }
    public void test() throws Exception {
        exe = Executors.newFixedThreadPool(POOL_SIZE);
        HttpParams params =new BasicHttpParams();
        /* 从连接池中取连接的超时时间 */
        ConnManagerParams.setTimeout(params, 1000);
        /* 连接超时 */
        HttpConnectionParams.setConnectionTimeout(params, 2000);
        /* 请求超时 */
        HttpConnectionParams.setSoTimeout(params, 4000);
        SchemeRegistry schemeRegistry = new SchemeRegistry();
        schemeRegistry.register(
                new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));

        //ClientConnectionManager cm = new PoolingClientConnectionManager(schemeRegistry);
        PoolingClientConnectionManager cm=new PoolingClientConnectionManager(schemeRegistry);
        cm.setMaxTotal(10);
        final HttpClient httpClient = new DefaultHttpClient(cm,params);

        // URIs to perform GETs on
        final String[] urisToGet = urls;
        /* 有多少url创建多少线程，url多时机子撑不住
        // create a thread for each URI
        GetThread[] threads = new GetThread[urisToGet.length];
        for (int i = 0; i < threads.length; i++) {
            HttpGet httpget = new HttpGet(urisToGet[i]);
            threads[i] = new GetThread(httpClient, httpget);           
        }
        // start the threads
        for (int j = 0; j < threads.length; j++) {
            threads[j].start();
        }

        // join the threads，等待所有请求完成
        for (int j = 0; j < threads.length; j++) {
            threads[j].join();
        }
        使用线程池*/
        for (int i = 0; i < urisToGet.length; i++) {
            final int j=i;
            System.out.println(j);
            HttpGet httpget = new HttpGet(urisToGet[i]);
            exe.execute( new GetThread(httpClient, httpget));
        }
       
       
        //创建线程池，每次调用POOL_SIZE
        /*
        for (int i = 0; i < urisToGet.length; i++) {
            final int j=i;
            System.out.println(j);
            exe.execute(new Thread() {
                @Override
                public void run() {
                    this.setName("threadsPoolClient"+j);
                   
                        try {
                            this.sleep(100);
                            System.out.println(j);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                       
                        HttpGet httpget = new HttpGet(urisToGet[j]);
                        new GetThread(httpClient, httpget).get();
                    }
                   
                   
               
            });
        }
       
        */
        //exe.shutdown();
        System.out.println("Done");
    }
    static class GetThread extends Thread{
       
        private final HttpClient httpClient;
        private final HttpContext context;
        private final HttpGet httpget;
       
        public GetThread(HttpClient httpClient, HttpGet httpget) {
            this.httpClient = httpClient;
            this.context = new BasicHttpContext();
            this.httpget = httpget;
        }
        @Override
        public void run(){
            this.setName("threadsPoolClient");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            get();
        }
       
        public void get() {
            try {
                HttpResponse response = this.httpClient.execute(this.httpget, this.context);
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    System.out.println(this.httpget.getURI()+": status"+response.getStatusLine().toString());
                }
                // ensure the connection gets released to the manager
                EntityUtils.consume(entity);
            } catch (Exception ex) {
                this.httpget.abort();
            }finally{
                httpget.releaseConnection();
            }
        }
    }
}


2、多线程异步请求


package generate.httpclient;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.impl.nio.client.DefaultHttpAsyncClient;
import org.apache.http.nio.client.HttpAsyncClient;
import org.apache.http.nio.reactor.IOReactorException;

public class AsynClient{
    /**
     * @param args
     * @throws IOReactorException
     * @throws InterruptedException
     */
    private List<String> urls;
    private HandlerFailThread failHandler;
    public AsynClient(List<String> list){
        failHandler=new HandlerFailThread();
        urls=list;
    }
    public Map<String,String> asynGet() throws IOReactorException,
            InterruptedException {
        final HttpAsyncClient httpclient = new DefaultHttpAsyncClient();
        httpclient.start();
        int urlLength=urls.size();
        HttpGet[] requests = new HttpGet[urlLength];
        int i=0;
        for(String url : urls){
            requests[i]=new HttpGet(url);
            i++;
        }
        final CountDownLatch latch = new CountDownLatch(requests.length);
        final Map<String, String> responseMap=new HashMap<String, String>();
        try {
            for (final HttpGet request : requests) {
                httpclient.execute(request, new FutureCallback<HttpResponse>() {

                    public void completed(final HttpResponse response) {
                        latch.countDown();
                        responseMap.put(request.getURI().toString(), response.getStatusLine().toString());
                        try {
                            System.out.println(request.getRequestLine() + "->"
                                    + response.getStatusLine()+"->");
                            //+readInputStream(response.getEntity().getContent())
                           
                        } catch (IllegalStateException e) {
                            failHandler.putFailUrl(request.getURI().toString(),
                                    response.getStatusLine().toString());
                            e.printStackTrace();
                        } catch (Exception e) {
                            failHandler.putFailUrl(request.getURI().toString(),
                                    response.getStatusLine().toString());
                            e.printStackTrace();
                        }
                    }

                    public void failed(final Exception ex) {
                        latch.countDown();
                        ex.printStackTrace();
                        failHandler.putFailUrl(request.getURI().toString(),
                                ex.getMessage());
                    }

                    public void cancelled() {
                        latch.countDown();
                    }

                });
            }
            System.out.println("Doing...");
        } finally {
            latch.await();
            httpclient.shutdown();
        }
        System.out.println("Done");
        failHandler.printFailUrl();
        return responseMap;
    }
    private String readInputStream(InputStream input) throws IOException{
        byte[] buffer = new byte[128];
        int len = 0;
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        while((len = input.read(buffer)) >= 0) {
            bytes.write(buffer, 0, len);
        }
        return bytes.toString();
    }
    /**
     * Test
     * @param args
     */
    public static void main(String[] args) {
        List<String> urls=new ArrayList<String>();
        urls.add("http://127.0.0.1/examples/servlets/");
        urls.add("http://127.0.0.1/examples/servlets/");
        urls.add("http://127.0.0.1/examples/servlets/");
        for(int i=0;i<10;i++){
            urls.addAll(urls);
        }
        System.out.println(urls.size());
        AsynClient client=new AsynClient(urls);
        try {
            client.asynGet();
        } catch (IOReactorException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("done");
    }
}


创建一个线程记录失败的请求

package generate.httpclient;

import java.util.HashMap;
import java.util.Map;

public class HandlerFailThread  extends Thread{
    Map<String, String> failUrl=new HashMap<String, String>();
    public void putFailUrl(String url,String status){
        synchronized (failUrl) {
            failUrl.put(url,status);
        }
    }
    @Override
    public void run() {
        while(true){
           
        }
    }
    public void printFailUrl(){
        for(Map.Entry<String, String> m: failUrl.entrySet()){
            System.out.println("****fail:url:"+m.getKey()+ "  code :"+m.getValue());
        }
    }
}


异步请求，也可通过pool管理，例如

 ConnectingIOReactor nio=new DefaultConnectingIOReactor();
  PoolingClientAsyncConnectionManager manager=new PoolingClientAsyncConnectionManager(nio);
  manager.setMaxTotal(1000);
  manager.setDefaultMaxPerRoute(100);
  HttpParams params=new BasicHttpParams();
  /* 连接超时 */
  HttpConnectionParams.setConnectionTimeout(params, 10000);
  /* 请求超时 */
  HttpConnectionParams.setSoTimeout(params, 60*1000);
  DefaultHttpAsyncClient.setDefaultHttpParams(params);
  final HttpAsyncClient httpclient = new DefaultHttpAsyncClient(manager);
  httpclient.start();

 

HttpClient相关可参看，里面有很多说明与例子

http://hc.apache.org/httpcomponents-client-ga/tutorial/html/connmgmt.html

ewili
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
httpclient 多线程执行（原创）
shsh1234567890的博客
01-23 286
httpclient 多线程执行（原创）
http异步请求&Future异步多线程
无材可去补苍天
06-05 1769
http异步请求使用Apache提供的HttpAsyncClient
多线程和HTTP异步
mangzilu的博客
05-30 589
多线程和HTTP异步 场景 基于一个jvm下的批量执行业务。为了提高用户体验度。再多服务器多应用的情景下，使用多线程和HTTP异步。 注重点 ①数据重复消费 ②数据一致性 ③HTTP数据交互 业务实例 一、线程池配置 import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.ThreadP
HttpClient多线程并发问题
热门推荐
kobejayandy的专栏
11-24 5万+
这篇文章概括了怎样在多线程环境下安全的使用HttpClient。 建立连接 在HttpClient中使用多线程的一个主要原因是可以一次执行多个方法。在执行期间，每一个方法都使用一个HttpConnection实例。由于在同一时间多个连接只能安全地用于单一线程和方法和有限的资源，我们就必须确保连接分配给正确的方法。而MultiThreadedHttpConnectionManager完全可以
HttpClient多线程调用并返回值
千帆过尽仍是沧海
09-24 2660
新开发了一个汇总功能，为了组合数据的方便，所以接口提供非常小的粒度；但是因汇总是有多个时间、地理跨度、且查询数据量比较大，结果是200个请求查询时间非常缓慢，达到了413854毫秒，龟速！！！ 研究了下HttpClient的多线程调用，经多线程实现后，200个请求耗时61382毫秒，效果非常明显。以下是封装的HttpClientThreadUtil.java工具类：
使用java的HttpClient实现多线程并发
09-01
通过使用HttpClient的连接池和多线程，我们可以有效地并发执行HTTP GET请求，同时控制并发数量，避免过多的网络连接导致服务器压力过大。这种方式提高了请求效率，减少了资源消耗，并且遵循了最佳实践。
httpclient著名的多线程框架
07-05
在Android系统中，由于主线程不能执行耗时操作，否则会引发ANR（Application Not Responding）错误，因此利用HttpClient的多线程特性，可以将网络请求放到后台线程，保证UI的流畅性。 HttpClient的使用步骤通常包括...
httpclient多线程下载(分段下载)实践
03-26
本篇文章将深入探讨如何使用HTTPClient进行多线程分段下载的实践。 首先，我们要理解多线程下载的基本原理。多线程下载是通过将大文件分割成多个小段，每个线程负责下载一个或多个段，这样可以充分利用多核处理器的...
C#多线程下载demo
08-19
在C#编程中，多线程技术是一种关键的性能优化手段，特别是在处理耗时操作如大文件下载时。本示例“C#多线程下载demo”旨在展示如何利用多线程来加速文件的下载过程。多线程允许程序同时执行多个任务，从而提高效率并...
java模拟多线程http请求代码分享
08-27
Java 模拟多线程 HTTP 请求代码分享 本篇文章分享了 Java 模拟多线程 HTTP 请求的相关...同时，本篇文章也提供了多种相关知识点的解释，包括多线程编程、HTTP 请求、Apache HttpClient 库和 ExecutorService 框架等。
httpClient多线程问题
jueshengtianya的专栏
03-11 1304
问题： 今天线上出现一个httpclient的问题： java.lang.IllegalStateException: Connection is not open at org.apache.commons.httpclient.HttpConnection.assertOpen(HttpConnection.java:1 276) at org.apache.comm
java httpclient 异步请求_异步httpclient(httpasyncclient)的使用与总结
weixin_28197941的博客
02-16 2785
1. 前言应用层的网络模型有同步与异步。同步意味当前线程是阻塞的，只有本次请求完成后才能进行下一次请求;异步意味着所有的请求可以同时塞入缓冲区,不阻塞当前的线程;httpclient在4.x之后开始提供基于nio的异步版本httpasyncclient,httpasyncclient借助了Java并发库和nio进行封装(虽说NIO是同步非阻塞IO,但是HttpAsyncClient提供了回调的机制...
httpclient如何实现在一个连接中发送多次请求
璀璨下的一点星辰
09-28 8677
public class Sample { private static ResponseHandler&lt;String&gt; responseHandler = new ResponseHandler&lt;String&gt;() { @Override public String handleResponse( ...
HttpWebReques请求StreamReader.ReadToEnd阻塞现象，以及HttpClient实现一次连接多次请求
Koala_Ivy的博客
03-23 2778
1.HttpWebReques遇到的问题还是最近手上的项目的问题。。。遍历10万条数据，每一条都请求接口。之前的文章里已经记录 有些一个递归方法，来进行请求失败的重复请求。但同时，发现了一个问题，就是for循环里的请求，有一定的几率会线程假死掉。。。这是一件多么不科学的事，正在执行任务中的线程怎么可能被莫名其妙的被GC回收，我相信是我的代码原因造成的，但是在做了异常捕获之后。。依旧没有发现问题，整...
socket java 发送多次_java应用程序：httpclient如何实现在一个连接中发送多次 请求？...
weixin_33138675的博客
02-13 515
如题，最好能给个简单的demo,几行也可以，就是核心的在一个连接中允许多次发送请求的代码！谢谢各位了！我用的连接池，如下，就是想实现多次调用post均使用同一个打开的连接，如何实现？测试发现老是会重新建立连接(即新开端口进行通信)！public class HttpClientTestDemo {public static final int MAX_TOTAL_CONNECTIONS = 400...
防止HttpClient重复请求
u013112576的博客
11-16 5937
android HttpClient 设置超时后，若在设定的时间内没有返回数据，httpClient底层会重复请求， DefaultHttpClient client = new DefaultHttpClient(); client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 5000);// 请求超
HttpClient连续请求是报错
dwdqsa的博客
04-02 1126
HttpClient线程不安全 请求时加锁synchronized (lock) { httpResponse = httpClient.execute(httpPost); inputStream = httpResponse.getEntity().getContent(); result = IOUtils.toString(inputStream); }...
频繁使用httpclient请求
Kubernetes云计算的专栏
02-22 641
在httpclient请求是 如果在某段时间内频繁使用httpclient请求会会出现
httpclient多线程
最新发布
06-01
HttpClient 是一个多线程安全的 HTTP 客户端库，可以在多个线程中共享一个 HttpClient 实例。在使用 HttpClient 发起 HTTP 请求时，可以使用多线程来提高请求处理的效率。 下面是使用 HttpClient 进行多线程请求的示例代码： ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.HttpClientBuilder; public class HttpMultiThread { public static void main(String[] args) throws Exception { HttpClient httpClient = HttpClientBuilder.create().build(); ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i = 0; i < 100; i++) { executorService.execute(new HttpGetRequest(httpClient)); } executorService.shutdown(); } private static class HttpGetRequest implements Runnable { private HttpClient httpClient; public HttpGetRequest(HttpClient httpClient) { this.httpClient = httpClient; } @Override public void run() { HttpGet httpGet = new HttpGet("https://www.baidu.com"); try { httpClient.execute(httpGet); } catch (Exception e) { e.printStackTrace(); } } } } ``` 在上述代码中，我们使用了 ExecutorService 来创建一个固定大小的线程池，并将多个 HttpGetRequest 任务提交给线程池执行。在每个 HttpGetRequest 任务中，我们创建一个 HttpGet 请求，并使用 HttpClient 发起请求。 需要注意的是，HttpClient 的实例应该在多个线程之间共享，因此我们在 main 方法中创建了一个 HttpClient 实例，并将其传递给每个 HttpGetRequest 任务。同时，在使用 HttpClient 发起请求时，应该保证线程安全，避免多个线程同时使用同一个 HttpGet 实例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值