四核，i7。内存16G 

创建主类，启一个线程池大小为500.

public class TestThreadMax {
    private Logger logger = LoggerFactory.getLogger(TestThreadMax.class);
    private static final int len_thread = 500;
    static ExecutorService executor = Executors.newFixedThreadPool(len_thread);
    public static void main(String[] args) {
        for (int i=0;i<len_thread;i++){
            executor.submit(new SubClass());
        }
    }
}

创建子类，含IO操作

public class SubClass implements Runnable{
    private Logger logger = LoggerFactory.getLogger(com.test.common.utils.SubClass.class);
    @Override
    public void run() {
        try {
            String threadName = Thread.currentThread().getName();
            logger.info(threadName+"正在执行，当前时间"+System.currentTimeMillis());
            for(int i=0;i<100;i++){
//                logger.info("正在执行"+"D:/测试/"+threadName+"["+i+"].txt");
                File file = new File("D:/测试/"+threadName+"["+i+"].txt");
                if(!file.exists()){
                    file.createNewFile();
                }
                FileOutputStream fost = new FileOutputStream(file);
                String st = "我是测试数据"+i;
                try {
                    Thread.sleep(10);
                    fost.write(st.getBytes("utf8"));
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    fost.flush();
                    fost.close();
                }
            }
            logger.info(Thread.currentThread().getName()+"执行完毕，当前时间"+System.currentTimeMillis());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

CPU和内存运行情况如下：

总结：CPU瞬间干满了，内存基本无变化，IO操作肯定有波动。下附操作系统cpu调度进程和多线程的关系：

以下内容转载：https://www.cnblogs.com/fubaizhaizhuren/p/7501403.html

1. 什么是CPU

（1）         Central  Progressing  Unit 中央处理器，是一块超大规模的集成电路，是一台计算机的运算核心和控制核心。

（2）         CPU包括 运算器，高速缓冲存储器，总线。

（3）         它的工作，主要是解释计算机中的指令，和处理计算机软件中的数据。它在计算机中起着最重要的作用，构成了系统的控制中心，对各个应用程序进行统一协调和控制。

1. 线程

（1）         进程，一个进程就是一个具有独立功能的应用程序，关于某个数据集合上的一次运行活动。进程是系统进行资源分配和调度的一个独立单位。

（2）         线程，线程是进程的实体，属于进程，是CPU调度和分派的基本单位。

 资源分配给进程，所有线程共享该进程的资源

（3）         操作系统的设计，可以归纳为3点。

1. 以多进程形式，允许多个任务同时运行。
2. 以多线程形式，允许一个任务拆分成多个线程运行。
3. CPU提供协调机制，允许线程之间共享资源，防止线程之间产生冲突。
4. CPU和线程的关系

（1）         第一阶段，单CPU时代，单CPU在同一时间点，只能执行单一线程。比如，的某一刻00:00:00 这一秒，只计算1＋1=2（假设cpu每秒计算一次）

（2）         第二阶段，单CPU多任务阶段，计算机在同一时间点，并行执行多个线程。但这并非真正意义上的同时执行，而是多个任务共享一个CPU，操作系统协调CPU在某个时间点，执行某个线程，因为CPU在线程之间切换比较快，给人的感觉，就好像多个任务在同时运行。比如，电脑开了两个程序qq和qq音乐，假设这两个程序都只有一个线程。人能够感觉到CPU切换的频率是一秒一次，假设当前cpu计算速度是1秒1次，那么我们就能明显感到卡顿，当聊天，点击发送按钮时候，qq音乐就会停止运行。当前cpu计算速度是1秒100次，也就是它能在一秒之内在这两个进程见切换100次，那么我们就感不到卡顿，觉得QQ和QQ音乐是同时在运行。

（3）         第三阶段，多CPU多任务阶段，真正实现的，在同一时间点运行多个线程。具体到哪个线程在哪个CPU执行，这就跟操作系统和CPU本身的设计有关了。

1. 举例说明

（1）假设一种极端情况，一台单核计算机，只运行2个程序A和B。

假设A和B的优先级相同，A有3个线程，B有1个线程，那么CPU分配给A和B的执行时间应该是3:1。

（2）假设同一种情况发生在一台多核计算机，核1处理A和B各一个线程，核2处理A剩下的线程。

（3）刚才说的是线程只消耗CPU，在实际应用中这种情况是不存在的，程序总会跟资源打交道，比如读个文件，查询数据库，访问网络，这个时候多线程才能体现出优势。在一个进程中，让A先用一下CPU去查询数据库，在A查询数据库的时候CPU空闲，B就用一CPU去读文件，让C去访问网络。相对于查询数据库，读取文件这些操作来说，CPU的计算时间几乎可以忽略不计。所以，多线程，实际上是计算机多种资源的并行运用，跟CPU有几个核心没什么关系。

java多线程 后台做高并发接口测试

1.利用多线程 调用http请求 实现高并发 api性能测试
2.http请求远程调用工具类
3.多线程工具类如下：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import javax.annotation.PostConstruct;

import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import org.im4java.process.ProcessStarter;


//@Service
public class apiTest {

    /**
     * 定义并发线程数量
     */
    public static final int THREAD_NUM = 100;

    /**
     * 开始时间
     */
    private static long startTime = 0L;

    @PostConstruct
    public void init() {
        try {

            startTime = System.currentTimeMillis();
            System.out.println("CountDownLatch started at: " + startTime);

            // 初始化计数器为1
            CountDownLatch countDownLatch = new CountDownLatch(1);

            for (int i = 0; i < THREAD_NUM; i ++) {
                new Thread(new Run(countDownLatch)).start();
            }

            // 启动多个线程
            countDownLatch.countDown();

        } catch (Exception e) {
            System.out.println("Exception: " + e);
        }
    }

    /**
     * 线程类
     */
    private class Run implements Runnable {
        private final CountDownLatch startLatch;

        public Run(CountDownLatch startLatch) {
            this.startLatch = startLatch;
        }

        @Override
        public void run() {
            try {
                // 线程等待
                startLatch.await();

                // 执行操作
                /**
					这里调用你要测试的接口
				*/
                HttpClientUtil httpClientUtil = new HttpClientUtil();
                List<NameValuePair> formParams = new ArrayList<>();
                formParams.add(new BasicNameValuePair("edit","thumbnailImg"));
                formParams.add(new BasicNameValuePair("editType","center"));
                formParams.add(new BasicNameValuePair("width","400"));
                formParams.add(new BasicNameValuePair("height","400"));
                httpClientUtil.doPost("http://localhost:8080/test.action",formParams);
                long endTime = System.currentTimeMillis();
                System.out.println(Thread.currentThread().getName() + " ended at: " + endTime + ", cost: " + (endTime - startTime) + " ms.");
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        apiTest apiTest = new apiTest();
        apiTest.init();
    }
}

1 缘起

每次想使用多线程测试脚本时，总会忘记线程池的参数（我的脑袋没有太好用吧，就忘），
但是，我又想使用多线程测试，所以，想单纯的测试，是不是有简便的方法。
当然有。直接new Thread()。
曾经有和同事聊过，多线程编程，他们比较鄙视直接new Thread()，我也不知道为什么。
难道说使用线程池才会体现高级吗？
当然，高级就高级吧。
其实，我只是做一个脚本测试，不在后台生产环境跑服务，
所以，就直接使用new Thread()，比较方便。
这里不介绍线程池，只总结了Thread的几种使用方式。

2 如何启动线程

由Thread类可知，启用线程的方法为start()，即：new Thread().start()
start方法执行时其实有两个线程工作。
执行start的为当前线程，执行run方法的为另一个线程，即通过new Thread()创建的线程。
从何而知：源码。下面是start()方法的源码注释截图及源码，通过注释可知，如上所述。

start源码：java.lang.Thread#start

    /**
     * Causes this thread to begin execution; the Java Virtual Machine
     * calls the <code>run</code> method of this thread.
     * <p>
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the
     * <code>start</code> method) and the other thread (which executes its
     * <code>run</code> method).
     * <p>
     * It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
     * @see        #run()
     * @see        #stop()
     */
    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

3 测试

3.1 直接继承Thread

直接继承Thread类，需要重写run方法，在run方法里自定义逻辑。

package com.monkey.java_study.thread.pure_thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 继承Thread.
 *
 * @author xindaqi
 * @date 2022-04-21 11:24
 */
public class ExtendsThread extends Thread {

    private static final Logger logger = LoggerFactory.getLogger(ExtendsThread.class);

    private String threadName;

    public void setThreadName(String threadName) {
        this.threadName = threadName;
    }

    public String getThreadName() {
        return threadName;
    }

    public ExtendsThread() {

    }

    public ExtendsThread(String threadName) {
        super(threadName);
    }

    @Override
    public void run() {
        logger.info(">>>>>>>>>Extends Thread and Body in run, Thread name:{}", Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new ExtendsThread("t1");
        Thread t2 = new ExtendsThread("t2");

        t1.start();
        t2.start();
    }
}

• 运行结果
  

3.2 直接在Thread中直接写逻辑

如果不继承Thread如何自定义多线程呢？
Thread类的方法比较丰富，可以直接在Thread中填写逻辑。
调用的Thread方法为：java.lang.Thread#Thread(java.lang.Runnable, java.lang.String)
源码截图如下，通过构建第一个参数，初始化线程，使用语法()->，构建Runnable。
当然，有人会说，既然是Runnable类型的参数，为什么直接使用Runnable，
这可，可以，后面讲。

package com.monkey.java_study.thread.pure_thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 逻辑直接在Thread中.
 *
 * @author xindaqi
 * @date 2022-04-21 11:23
 */
public class BodyInThread {

    private static final Logger logger = LoggerFactory.getLogger(BodyInThread.class);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            logger.info(">>>>>>>>Body in thread, Thread name:{}", Thread.currentThread().getName());
            logger.info(">>>>>>>>");
        }, "t1");

        Thread t2 = new Thread(() -> {
            logger.info(">>>>>>>>Body in thread, Thread name:{}", Thread.currentThread().getName());
            logger.info(">>>>>>>>");
        }, "t2");

        t1.start();
        t2.start();
    }
}

• 运行结果
  

3.3 在Thread中调用方法

同样地，在Thread中可以直接写逻辑，也可以通过独立的方法实现逻辑，与上面一样：
调用的Thread方法为：java.lang.Thread#Thread(java.lang.Runnable, java.lang.String)
构建Runnable两种方式：语法::执行方法，或者()->。

package com.monkey.java_study.thread.pure_thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Thread中调用方法.
 *
 * @author xindaqi
 * @date 2022-04-21 11:23
 */
public class MethodInThread {

    private static final Logger logger = LoggerFactory.getLogger(MethodInThread.class);

    public static void methodTest() {
        logger.info(">>>>>>>>Method in thread, Thread name:{}", Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(MethodInThread::methodTest, "t1");
        Thread t2 = new Thread(() -> methodTest(), "t2");
        t1.start();
        t2.start();
    }
}

• 运行结果
  

3.4 实现Runnable

好了，这里是直接使用Runnable初始化线程，即实现Runnable接口，
初始化线程时，直接传入实例化的类即可。
同时，需要重写run方法，实现自定义逻辑。
当前的实现方式，以及上面的方法，线程执行的逻辑均没有返回值，
即多线程执行的方法无法获取方法返回值。

package com.monkey.java_study.thread.pure_thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Runnable在Thread中.
 *
 * @author xindaqi
 * @date 2022-04-21 11:42
 */
public class RunnableInThread implements Runnable {

    private static final Logger logger = LoggerFactory.getLogger(RunnableInThread.class);

    @Override
    public void run() {
        logger.info(">>>>>>>>Runnable in run, Thread name:{}", Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new RunnableInThread(), "t1");
        Thread t2 = new Thread(new RunnableInThread(), "t2");
        Thread t3 = new Thread(new RunnableInThread(), "t3");

        t1.start();
        t2.start();
        t3.start();
    }
}

• 运行结果
  

3.5 实现Callable

如果多线程需要获取返回值应该怎么办？
有没有方案？
有。实现Callable接口。
该接口通过FutureTask接口获取方法返回结果，FutureTask作为参数初始化Thread。
同样调用：java.lang.Thread#Thread(java.lang.Runnable, java.lang.String)
因此，FutureTask的层次接口中必定实现了Runnable接口。
FutureTask实现了RunnableFuture，RunnableFuture实现了Runnable和Future。
java.util.concurrent.FutureTask

java.util.concurrent.RunnableFuture

package com.monkey.java_study.thread.pure_thread;

import jdk.nashorn.internal.codegen.CompilerConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * Callable在Thread中.
 *
 * @author xindaqi
 * @date 2022-04-21 11:46
 */
public class CallableInThread implements Callable<String> {

    private static final Logger logger = LoggerFactory.getLogger(CallableInThread.class);

    @Override
    public String call() throws Exception {
        logger.info(">>>>>>>>Callable in call, Thread name:{}", Thread.currentThread().getName());
        return Thread.currentThread().getName();
    }

    public static void main(String[] args) throws Exception {
        Callable<String> callable1 = new CallableInThread();
        FutureTask<String> futureTask1 = new FutureTask<>(callable1);
        FutureTask<String> futureTask2 = new FutureTask<>(callable1);
        FutureTask<String> futureTask3 = new FutureTask<>(callable1);
        Thread t1 = new Thread(futureTask1, "t1");
        Thread t2 = new Thread(futureTask2, "t2");
        Thread t3 = new Thread(futureTask3, "t3");

        t1.start();
        logger.info(">>>>>>>>Thread1 result:{}", futureTask1.get());
        t2.start();
        logger.info(">>>>>>>>Thread2 result:{}", futureTask2.get());
        t3.start();
        logger.info(">>>>>>>>Thread3 result:{}", futureTask3.get());
    }
}

• 运行结果

4 小结

• Java通过Thread创建线程可分为4类：
  （1）继承Thread，重写run方法；
  （2）在Thread中写方法，构建Runnable类型，通过::或者()->构建；
  （3）实现Runnable接口，重写run方法；
  （4）实现Callable接口，重写call方法。
• 前三类无法获取方法返回值，第四类可以获取方法返回值。
• 启动线程使用start方法，该方法执行时有两个线程工作，即调用start的当前线程和调用run方法的其他线程（new Thread创建的线程）。