2021-03-18

package c.ct.thread;

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

/**
 * 计算capacity次结果。针对cpu密集型,线程数设置为机器当前核数。
 */
public class ExecutorTest {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        List<Future> result = new LinkedList<>();
        List<Future> futureTasks = Collections.unmodifiableList(result);
        int capacity = 10000000;
        Long begin = new GregorianCalendar().getTimeInMillis();
        System.out.println("begin="+begin);
       // ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()+1 );//11-14s
        ExecutorService service = Executors.newSingleThreadExecutor(); //6-8s,这个反而是消耗时间最小的。
       // ExecutorService service = Executors.newCachedThreadPool(); // 18-21s
       // ExecutorService service = new ThreadPoolExecutor(1,3,0,TimeUnit.MILLISECONDS,new LinkedBlockingQueue<>());//8s
        for(int i=0;i<capacity;i++){
            Callable<Integer> aa = new ThreadA("ThreadA "+ i);
            Future<Integer> task =  service.submit(aa);
            result.add(task);
        }
        service.shutdown();

        System.out.println("MAX="+Integer.MAX_VALUE);
        Integer total = 0;
        System.out.println(futureTasks.size());
        for (Future<Integer> task:futureTasks) {
            total += task.get();
        }
        System.out.println("total="+ total);
        Long end = new GregorianCalendar().getTimeInMillis();
        System.out.println("消耗(s)="+ (end- begin)/1000);





    }


    static class ThreadA implements Callable<Integer> {
        private AtomicInteger result = new AtomicInteger(0);
        private String name;

        public ThreadA(String name) {
            this.name = name;
        }

        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 10; i++) {
                result.addAndGet(i);
            }
            return   result.get();
        }
    }
}


why  newSingleThreadExecutor 1个核心线程执行时间最少？

newSingleThreadExecutor执行时间最少