java代码模拟并发请求

淩亂°似流年 2023-06-30 11:59 17阅读 0赞

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

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

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

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

只需要：

1.  开启n个线程，加一个闭锁，开启所有线程；
2.  待所有线程都准备好后，按下开启按钮，就可以真正的发起并发请求了。  
    如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;
        }
        
    }

如上，就可以发起真正的并发请求了。  
并发请求操作流程示意图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpYXppbGlwaW5n_size_16_color_FFFFFF_t_70]  
*此处设置了一道门，以保证所有线程可以同时生效。但是，此处的同时启动，也只是语言层面的东西，也并非绝对的同时并发。具体的调用还要依赖于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...");
        }
    }

其运行结果如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpYXppbGlwaW5n_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpYXppbGlwaW5n_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020011715575057.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpYXppbGlwaW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpYXppbGlwaW5n_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200117160330437.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpYXppbGlwaW5n,size_16,color_FFFFFF,t_70