java手写简易版自定义线程池 V2

import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class DdqThreadPool {
    private final List<Queue<Runnable>> taskQueues;
    private final List<DdqThread> ddqThreads;

    private DdqThreadPool(int maxThreadSize) {
        this.taskQueues = new ArrayList<>(maxThreadSize);
        this.ddqThreads = new ArrayList<>(maxThreadSize);
        for (int idx = 0; idx < maxThreadSize; idx++) {
            this.taskQueues.add(new LinkedBlockingQueue<>());
            this.ddqThreads.add(new DdqThread("ddqThread" + idx, idx));
        }
        this.ddqThreads.forEach(DdqThread::start);
    }

    private final class DdqThread extends Thread {
        private final int idx;

        private DdqThread(String name, int idx) {
            super(name);
            this.idx = idx;
        }

        private void doRun() {
            Queue<Runnable> taskQueue = taskQueues.get(idx);
            Runnable task;
            while (true) {
                try {
                    if ((task = taskQueue.poll()) != null) task.run();
                } catch (Exception exception) {
                    exception.printStackTrace();
                }
            }
        }

        @Override
        public void run() {
            doRun();
        }
    }

    private int randomIndex() {
        return (int) (Math.random() * taskQueues.size());
    }

    public int poolSize() {
        return ddqThreads.size();
    }

    public void execute(Runnable task) {
        if (task == null) throw new IllegalArgumentException("runnable不能为null");
        taskQueues.get(randomIndex()).offer(task);
    }

    public static DdqThreadPool newDdqThreadPool(int maxThreadSize) {
        if (maxThreadSize < 1) throw new IllegalArgumentException("线程数量必须大于0");
        return new DdqThreadPool(maxThreadSize);
    }

    private static void test1() throws Exception {
        DdqThreadPool ddqThreadPool = DdqThreadPool.newDdqThreadPool(5);
        CountDownLatch countDownLatch = new CountDownLatch(1000);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            ddqThreadPool.execute(countDownLatch::countDown);
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println("ddqThreadPool:" + (end - start));
    }

    private static void test2() throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        CountDownLatch countDownLatch = new CountDownLatch(1000);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            executorService.execute(countDownLatch::countDown);
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println("executorService:" + (end - start));
    }

    private static void test3() throws Exception {
        CountDownLatch countDownLatch = new CountDownLatch(1000);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            new Thread(countDownLatch::countDown).start();
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println("普通thread:" + (end - start));
    }

    private static void sleep(long timeout) {
        try {
            Thread.sleep(timeout);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws Exception {
        //自定义的线程池进行测试 cost 8ms
        test1();
        sleep(3000L);
        //java juc自带的线程池进行测试 cost 79ms
        test2();
        sleep(3000L);
        //最原始的线程池进行测试 cost 543ms
        test3();
    }
}

V1版本请点击此处