Executors几种常用的线程池性能比较

java编程中,经常会利用Executors的newXXXThreasPool生成各种线程池,今天写了一小段代码,简单测试了下三种常用的线程池:

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 测试类(因为要用到forkjoin框架,所以得继承自RecursiveXXX)
 */
public class MathTest extends RecursiveAction {

    private List<Integer> target;

    private static AtomicInteger count = new AtomicInteger(0);

    public MathTest(List<Integer> list) {
        this.target = list;
    }


    public double process(Integer d) {
        //模拟处理数据耗时200ms
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //System.out.println("thread:" + Thread.currentThread().getId() + "-" + Thread.currentThread().getName() + ", d: " + d);
        return d;
    }


    @Override
    protected void compute() {
        if (target.size() <= 2) {
            for (Integer d : target) {
                process(d);
                count.incrementAndGet();
            }
            return;
        }
        int mid = target.size() / 2;
        MathTest t1 = new MathTest(target.subList(0, mid));
        MathTest t2 = new MathTest(target.subList(mid, target.size()));
        t1.fork();
        t2.fork();
    }


    public static void main(String[] args) {
        int num = 100;
        int threadCount = 4;
        List<Integer> target = new ArrayList<>(num);
        for (int i = 0; i < num; i++) {
            target.add(i);
        }

        MathTest test = new MathTest(target);

        //原始方法,单线程跑
        long start = System.currentTimeMillis();
        for (int i = 0; i < target.size(); i++) {
            test.process(target.get(i));
        }
        long end = System.currentTimeMillis();
        System.out.println("原始方法耗时:" + (end - start) + "\n");


        //固定线程池
        final ThreadFactory fixedFactory = new ThreadFactoryBuilder().setNameFormat("fixed-%d").build();
        ExecutorService service = Executors.newFixedThreadPool(threadCount, fixedFactory);

        count.set(0);
        start = System.currentTimeMillis();
        for (Integer d : target) {
            service.submit(() -> {
                test.process(d);
                count.incrementAndGet();
            });
        }
        while (true) {
            if (count.get() >= target.size()) {
                end = System.currentTimeMillis();
                System.out.println("fixedThreadPool耗时:" + (end - start) + "\n");
                break;
            }
        }


        //cached线程池
        final ThreadFactory cachedFactory = new ThreadFactoryBuilder().setNameFormat("cached-%d").build();
        service = Executors.newCachedThreadPool(cachedFactory);
        count.set(0);
        start = System.currentTimeMillis();
        for (Integer d : target) {
            service.submit(() -> {
                test.process(d);
                count.incrementAndGet();
            });
        }
        while (true) {
            if (count.get() >= target.size()) {
                end = System.currentTimeMillis();
                System.out.println("cachedThreadPool耗时:" + (end - start) + "\n");
                break;
            }
        }


        //newWorkStealing线程池
        service = Executors.newWorkStealingPool(threadCount);
        count.set(0);
        start = System.currentTimeMillis();
        for (Integer d : target) {
            service.submit(() -> {
                test.process(d);
                count.incrementAndGet();
            });
        }
        while (true) {
            if (count.get() >= target.size()) {
                end = System.currentTimeMillis();
                System.out.println("workStealingPool耗时:" + (end - start) + "\n");
                break;
            }
        }


        //forkJoinPool
        ForkJoinPool forkJoinPool = new ForkJoinPool(threadCount);
        count.set(0);
        start = System.currentTimeMillis();
        forkJoinPool.submit(test);
        while (true) {
            if (count.get() >= target.size()) {
                end = System.currentTimeMillis();
                System.out.println("forkJoinPool耗时:" + (end - start) + "\n");
                break;
            }
        }


    }
}

代码很简单,就是给一个List,然后对里面的每个元素做处理(process方法),用三种线程池分别跑了一下,最后看耗时,输出如下:

原始方法耗时:20156

fixedThreadPool耗时:5145

cachedThreadPool耗时:228

workStealingPool耗时:5047

forkJoinPool耗时:5042

环境:mac + intel i5(虚拟4核)。 workStealingPool内部其实就是ForkJoin框架,所以二者在耗时上基本一样,符合预期;如果业务的处理时间较短,从测试结果来看,cachedThreadPool最快。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券