java代码模拟并发请求-蒲公英云

转载：https://www.cnblogs.com/yougewe/p/9745198.html

java中如何模拟真正的同时并发请求？

有时需要测试一下某个功能的并发性能，又不要想借助于其他工具，【试过用postman工具，delay为0貌似还是串行，并非是并发】索性就自己的开发语言，来一个并发请求就最方便了。

java中模拟并发请求，自然是很方便的，只要多开几个线程，发起请求就好了。但是，这种请求，一般会存在启动的先后顺序了，算不得真正的同时并发！怎么样才能做到真正的同时并发呢？是本文想说的点，java中提供了闭锁 CountDownLatch, 刚好就用来做这种事就最合适了。

只需要：

开启n个线程，加一个闭锁，开启所有线程；

待所有线程都准备好后，按下开启按钮，就可以真正的发起并发请求了。
如BingFaTest.java Junit测试

package com.launch.sharedevice;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
import andy.config.RestTemplateConfig;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={ “classpath:spring.xml”,”classpath:spring-mybatis.xml”,”classpath:spring-rabbitmq.xml”})
@WebAppConfiguration
public class BingFaTest {

private Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
private RestTemplate restTemplate;
@Test
public void everTest() throws InterruptedException  { 
    Runnable taskTemp = new Runnable() { 
        // 注意，此处是非线程安全的，留坑
        private int iCounter;
        @Override
        public void run() { 
            for(int i = 0; i < 10; i++) { 
                // --------------发起请求--------------------
                // url为项目中的某个接口
                String url = "http://localhost:9080/repair/device/close";
                Map<String, Object> map = new HashMap<>();
                map.put("mechanicCode", "590026109");
                map.put("deviceNo", "980000000000");
                HttpEntity<MultiValueMap<String, Object>> paramrequest = RestTemplateConfig.getFormDataHttpEntity(map);
                String result = restTemplate.postForObject(url, paramrequest, String.class);
                logger.info("---------result>:"+result);
                // --------------请求结束--------------------
                iCounter++;
                System.out.println(System.nanoTime() + " runnable[" + Thread.currentThread().getName() + "] iCounter = " + iCounter);
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }
        }
    };
    long total = startTaskAllInOnce(5, taskTemp);
    System.out.println("----消耗时间为>:"+total);
}
public long startTaskAllInOnce(int threadNums, final Runnable task) throws InterruptedException { 
    final CountDownLatch startGate = new CountDownLatch(1);
    final CountDownLatch endGate = new CountDownLatch(threadNums);
    for(int i = 0; i < threadNums; i++) { 
        Thread t = new Thread() { 
            public void run() { 
                try { 
                    // 使线程在此等待，当开始门打开时，一起涌入门中
                    startGate.await();
                    try { 
                        task.run();
                    } finally { 
                        // 将结束门减1，减到0时，就可以开启结束门了
                        endGate.countDown();
                    }
                } catch (InterruptedException ie) { 
                    ie.printStackTrace();
                }
            }
        };
        t.start();
    }
    long startTime = System.nanoTime();
    System.out.println(startTime + " [" + Thread.currentThread() + "] All thread is ready, concurrent going...");
    // 因开启门只需一个开关，所以立马就开启开始门
    startGate.countDown();
    // 等等结束门开启
    endGate.await();
    long endTime = System.nanoTime();
    System.out.println(endTime + " [" + Thread.currentThread() + "] All thread is completed.");
    return endTime - startTime;
}

}

如上，就可以发起真正的并发请求了。
并发请求操作流程示意图如下：
在这里插入图片描述
此处设置了一道门，以保证所有线程可以同时生效。但是，此处的同时启动，也只是语言层面的东西，也并非绝对的同时并发。具体的调用还要依赖于CPU个数，线程数及操作系统的线程调度功能等，不过咱们也无需纠结于这些了，重点在于理解原理！

CyclicBarrier

与 CountDownLatch 有类似功能的，还有个工具栅栏 CyclicBarrier, 也是提供一个等待所有线程到达某一点后，再一起开始某个动作，效果一致，不过栅栏的目的确实比较纯粹，就是等待所有线程到达，而前面说的闭锁 CountDownLatch 虽然实现的也是所有线程到达后再开始，但是他的触发点其实是最后那一个开关，所以侧重点是不一样的。简单看一下栅栏是如何实现真正同时并发呢？示例如下：

// 与 闭锁 结构一致
public class LatchTest { 
    public static void main(String[] args) throws InterruptedException { 
        Runnable taskTemp = new Runnable() { 
            private int iCounter;
            @Override
            public void run() { 
                // 发起请求
// HttpClientOp.doGet("https://www.baidu.com/");
                iCounter++;
                System.out.println(System.nanoTime() + " [" + Thread.currentThread().getName() + "] iCounter = " + iCounter);
            }
        };
        LatchTest latchTest = new LatchTest();
// latchTest.startTaskAllInOnce(5, taskTemp);
        latchTest.startNThreadsByBarrier(5, taskTemp);
    }
    public void startNThreadsByBarrier(int threadNums, Runnable finishTask) throws InterruptedException { 
        // 设置栅栏解除时的动作，比如初始化某些值
        CyclicBarrier barrier = new CyclicBarrier(threadNums, finishTask);
        // 启动 n 个线程，与栅栏阀值一致，即当线程准备数达到要求时，栅栏刚好开启，从而达到统一控制效果
        for (int i = 0; i < threadNums; i++) { 
            Thread.sleep(100);
            new Thread(new CounterTask(barrier)).start();
        }
        System.out.println(Thread.currentThread().getName() + " out over...");
    }
}
class CounterTask implements Runnable { 
    // 传入栅栏，一般考虑更优雅方式
    private CyclicBarrier barrier;
    public CounterTask(final CyclicBarrier barrier) { 
        this.barrier = barrier;
    }
    public void run() { 
        System.out.println(Thread.currentThread().getName() + " - " + System.currentTimeMillis() + " is ready...");
        try { 
            // 设置栅栏，使在此等待，到达位置的线程达到要求即可开启大门
            barrier.await();
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } catch (BrokenBarrierException e) { 
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " - " + System.currentTimeMillis() + " started...");
    }
}