java多线程压力测试《搬代码》

1.首先要创建线程池
Executors.newCachedThreadPool()
2.创建同步计数器
new CountDownLatch(）
3.创建通过许可证的计数器实现同步
new Semaphore（）
4.fori循环
5.fori循环中使用

package com.znzdh.jiekou;

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

@Slf4j
public class fighting{
    //总的请求个数
   public static final int requestTotal =1000;
   //用来计数看一下是否执行1000次，for循环中使用
    public static  int a =0;
   //同一时刻最大的并发线程的个数
    public static final int concurrentThreadNum = 20;
   public static void main(String[] args) throws InterruptedException {
        //创建线程池
       ExecutorService executorService = Executors.newCachedThreadPool();
        //创建同步计数器
       CountDownLatch countDownLatch = new CountDownLatch(requestTotal);
       //创建通过一个许可证的计数器来实现同步
       Semaphore semaphore = new Semaphore(concurrentThreadNum);
       for (int i = 0; i < requestTotal; i++) {
           a++;
           System.out.println(a);
           executorService.execute(()->{
               try {
                   //在需要访问共享资源的线程中，可以调用 acquire() 方法来获取许可证
                   semaphore.acquire();
                   //调用方法如果不需要String类型，只需要调用方法，可以将方法的String改成void
                  String result= testRequestUn();
                  log.info("result:{}",result);
                  //当线程完成对共享资源的访问后，需要调用 release() 方法来释放许可证
                   semaphore.release();
               } catch (InterruptedException e) {
                   log.error("exception",e);
               }
               //每个线程执行完之后，调用 countDown() 方法来减少计数器的值
               countDownLatch.countDown();
           });
       }
       //使当前线程等待，直到计数器变为 0
       countDownLatch.await();
       //停止接收新任务，原来的任务继续执行
       executorService.shutdown();
       System.out.println("11111111111111111111");
       log.info("请求完成");
       System.out.println("11111111111111111111");
   }
	//要执行的程序，如果不需要返回值可以改成void
    private static String testRequestUn() {
        return null;
    }

}

不断创建新线程：ExecutorService executorService = Executors.newCachedThreadPool();
线程会被复用：ExecutorService.executorService=Executors.newFixedThreadPool(concurrentThreadNum);