线程池和直接创建线程的简单性能对比

转自https://blog.csdn.net/u014104286/article/details/71775038

都说线程池的性能比直接创建线程（新学了一个词，叫野线程😂）性能要高，简单的做了个实验，未必准确仅供参考，先上结论

实验平台mac系统，8代i7处理器，16G内存，十万次创建线程，差距是50倍以上。

通过线程池创建：

package concurrent.performanceTestWithOriginThread;

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class OneHundredThousandWithThreadPool {

  private ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();
  //	private ArrayList<String> queue = new ArrayList<String>();
//	private CyclicBarrier barrier = new CyclicBarrier(10000000);
  private CountDownLatch latch = new CountDownLatch(100000);
  ExecutorService excutor = Executors.newFixedThreadPool(4);

  public static void main(String[] args) {
    OneHundredThousandWithThreadPool test001 = new OneHundredThousandWithThreadPool();
    long timeStart = System.currentTimeMillis();
    test001.start();
    System.out.println(System.currentTimeMillis() - timeStart);
  }

  public void start() {
    for (int i = 0; i < 100000; i++) {
      Runnable001 runnable001 = this.new Runnable001(i);
      excutor.submit(runnable001);
//			new Thread(runnable001).start();
    }
    excutor.shutdown();
    try {
      //等待latch计数为0
      latch.await();
    } catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println(queue.size());
  }

  private class Runnable001 implements Runnable {
    private int value;

    public Runnable001(int value) {
      this.value = value;
    }

    @Override
    public void run() {
      try {
//				barrier.await();
      } catch (Exception e) {
        e.printStackTrace();
      }
      queue.offer(value + "");
      latch.countDown();//latch计数减一
    }

  }
}

           

通过野线程创建：

package concurrent.performanceTestWithOriginThread;

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;

public class OneHundredThousandWithThread
{
  private ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();
  //	private ArrayList<String> queue = new ArrayList<String>();
//	private CyclicBarrier barrier = new CyclicBarrier(10000000);
  private CountDownLatch latch = new CountDownLatch(100000);

  public static void main(String[] args) {
    OneHundredThousandWithThread test001 = new OneHundredThousandWithThread();
    long timeStart = System.currentTimeMillis();
    test001.start();
    System.out.println(System.currentTimeMillis() - timeStart);
  }

  public void start() {
    for (int i = 0; i < 100000; i++) {
      OneHundredThousandWithThread.Runnable001 runnable001 = this.new Runnable001(i);
//      excutor.submit(runnable001);
			new Thread(runnable001).start();
    }
    try {
      //等待latch计数为0
      latch.await();
    } catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println(queue.size());
  }

  private class Runnable001 implements Runnable {
    private int value;

    public Runnable001(int value) {
      this.value = value;
    }

    @Override
    public void run() {
      try {
//				barrier.await();
      } catch (Exception e) {
        e.printStackTrace();
      }
      queue.offer(value + "");
      latch.countDown();//latch计数减一
    }
  }
}