六種執行緒池：

FixedThreadPool

CacheThreadPool

SingleThreadExecutor

ScheduledThreadPool

ForjJoinPool

WorkStealingPool

package Thread26;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class MyCachePool {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();
        System.out.println(service);

        for (int i=0; i<2 ;i++) {
            service.execute(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        System.out.println(service);
        TimeUnit.SECONDS.sleep(80);
        System.out.println(service);
    }
}

package Thread26;

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

public class MyParallelComputing {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        List<Integer> results = MyTask.getPrime(1,200000);
        for (Integer integer : results){
            System.out.println(integer);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

        final int cpuCoreNum = 4;

        ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);

        MyTask t1 = new MyTask(1,80000);
        MyTask t2 = new MyTask(80001,130000);
        MyTask t3 = new MyTask(130001,170000);
        MyTask t4 = new MyTask(170001,200000);

        Future<List<Integer>> f1 = service.submit(t1);
        Future<List<Integer>> f2 = service.submit(t2);
        Future<List<Integer>> f3 = service.submit(t3);
        Future<List<Integer>> f4 = service.submit(t4);

        start = System.currentTimeMillis();
        f1.get();
        f2.get();
        f3.get();
        f4.get();
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }
    static class MyTask implements Callable<List<Integer>>{
        int startPos,endPos;
        MyTask(int s,int e){
            this.startPos = s;
            this.endPos = e;
        }

        @Override
        public List<Integer> call() throws Exception {
            List<Integer> r = getPrime(startPos,endPos);
            return r;
        }

        static boolean isPrime(int num) {
            for (int i = 2; i<num/2;i++) {
                if (num % i == 0){
                    return false;
                }
            } return true;
        }
        static List<Integer> getPrime(int start,int end){
            List<Integer> result = new ArrayList<>();
            for (int i = start;i<=end;i++){
                if (isPrime(i)){
                    result.add(i);
                }
            }
            return result;
        }
    }
}

package Thread26;

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class MyWorkStrealingPool {
    public static void main(String[] args) throws IOException {
        ExecutorService service = Executors.newWorkStealingPool();

        service.execute(new R(1000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000));

        System.in.read();
    }
    static class R implements Runnable {
        int time;
        R(int t) {
            this.time = t;
        }

        @Override
        public void run() {
            try {
                TimeUnit.MILLISECONDS.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(time + ""+Thread.currentThread().getName());
        }
    }
}

package Thread26;


import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;

public class MyForkJoinPool {
    static int[] nums = new int[1000000];
    static final int MAX_NUM = 50000;
    static Random random = new Random();

    static {
        for (int i=0 ; i<nums.length ;i++) {
            nums[i] = random.nextInt(100);
        }
        System.out.println(Arrays.stream(nums).sum());
    }
    static class AddTask extends RecursiveAction {
        int start,end;

        AddTask(int s,int e) {
            start = s;
            end = e;
        }

        @Override
        protected void compute() {
            if (end - start <= MAX_NUM) {
                long sum = 0L;
                for (int i = start;i<end;i++) {
                    sum += nums[i];
                    System.out.println("from" + start +"to:"+end+"="+sum);
                }
            }else {
                int middle  = start + (end+start)/2;

                AddTask subTask1 = new AddTask(start,middle);
                AddTask subTask2 = new AddTask(middle,end);
                subTask1.fork();
                subTask2.fork();
            }
        }
    }

    static class AddTask1 extends RecursiveTask<Long> {

        int start,end;

        AddTask1(int s,int e) {
            start = s;
            end = e;
        }

        @Override
        protected Long compute() {
            if (end - start <= MAX_NUM) {
                long sum = 0L;
                for (int i = start; i< end;i++) {
                    sum += nums[i];
                    return sum;
                }
            }
            int middle = start + (end+start)/2;
            AddTask subTask1 = new AddTask(start,middle);
            AddTask subTask2 = new AddTask(middle,end);
            subTask1.fork();
            subTask2.fork();

            return subTask1.join()+subTask2.join();
        }
    }

    public static void main(String[] args) throws IOException {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        AddTask task = new AddTask(0,nums.length);
        forkJoinPool.execute(task);
        System.in.read();
    }
}