Java线程池及其底层源码实现分析

ExecutorService service = Executors.newFixedThreadPool(5);//创建5个线程的线程池
ThreadPool线程池类（装着线程的容器）

public class TestThreadPool{
2
    public static void main(String[] args){
3
        ExecutorService service = Executors.newFixedThreadPool(5);//1.创建5个线程的线程池容器
4
        
5
        for(int i=0;i {
7
                System.out.println(Thread.getCurrentThread().getName());//3.打印出当前线程名
8
            });
9
        }
10
        service.shutdown();//执行完当前任务则关闭线程
11
        service.shutdownNow();//无论是否执行完都关闭线程
12
    }
13
}

public class TestFuture{
2
    public static void main(String[] args){
3
        //FutureTask实现类Runnable和Future接口
4
        FutureTask task = new FutureTask(
5
            Thread.sleep(500);//阻塞等待500毫秒
6
            return 1000;
7
        );
8
        
9
        //new的方式启动线程任务
10
        new Thread(task).start();
11
        System.out.println(task.get());//阻塞等待500毫秒后得到返回值
12
        ///////////////////////////////////////////////////////////////////
13
        ExecutorService service = Executors.newFixedThreadPool(5);//创建5个线程的线程池
14
        Future future = service.submit(()->{//相当于运行类callable接口的call方法，返回1
15
            Thread.sleep(500);
16
            return 1;
17
        });
18
        System.out.println(future.get());//阻塞等待500毫秒后得到返回值
19
    }
20
}

public class WorkStealingPoolTest {
2
    public static void main(String[] args) throws IOException {
3
        //根据CPU核数启动相应个数的线程（4核cpu---4个线程）
4
        ExecutorService service = Executors.newWorkStealingPool();
5
        System.out.println(Runtime.getRuntime().availableProcessors());
6
7
        service.execute(new R(1000));//线程1执行任务1----1秒
8
        service.execute(new R(2000));//线程2执行任务2----2秒
9
        service.execute(new R(2000));//线程3执行任务3----2秒
10
        service.execute(new R(2000));//线程4执行任务4----2秒
11
        service.execute(new R(2000));//任务5阻塞，当线程1执行完后把任务5偷过来执行
12
        
13
        //由于产生的是守护线程，主线程不阻塞的话，看不到输出
14
        System.in.read();//将主线程阻塞 
15
    }
16
17
    static class R implements Runnable {
18
19
        int time;
20
21
        R(int t) {
22
            this.time = t;
23
        }
24
25
        @Override
26
        public void run() {
27
            
28
            try {
29
                TimeUnit.MILLISECONDS.sleep(time);
30
            } catch (InterruptedException e) {
31
                e.printStackTrace();
32
            }
33
            //打印线程名---ForkJoinPool
34
            System.out.println(time  + " " + Thread.currentThread().getName());
35
            
36
        }
37
38
    }
39
}

public class ForkJoinPoolTest{
2
        
3
        public static void main(String[] args) throws Exception {
4
        ForkJoinPool pool = new ForkJoinPool();
5
        MyTask task = new MyTask(inits, 0, inits.;ength-1);
6
        ForkJoinTask taskResult = pool.submit(task);
7
        try {
8
            taskResult.get();//阻塞等待所有线程结果计算完成
9
        } catch (InterruptedException | ExecutionException e) {
10
            e.printStackTrace(System.out);
11
        }
12
    }
13
14
    /**
15
     * 单个排序的子任务
16
     */
17
    static class MyTask extends RecursiveTask {
18
19
        private int[] source;
20
        private int start;
21
        private int end;
22
23
        public MyTask(int[] source,int start, int end ) {
24
            this.source = source;
25
            this.start = start;
26
            this.end = end;
27
        }
28
29
30
        @Override
31
        protected int[] compute() {
32
            //长度小于50，进行计算
33
            if(source.length 

ThreadPoolExecutor(int corePoolSize,//核心线程数（最小）

                   int maximumPoolSize,//最大线程数

                   long keepAliveTime, //线程运行时间

                   TimeUnit unit, //时间单位

                   BlockingQueue workQueue)//底层采用哪种阻塞队列来放线程任务 

　　各种线程池的底层实现：

//FixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads){
     return new ThreadPoolExecutor(nThreads,//初始线程数自定义
                    nThreads,//最大线程数自定义
                    0L, TimeUnit.SECONDS,//一旦启动线程池，线程永远不消失
                    new LinkedBlockingQueue());//链表阻塞队列
    }

//CachedThreadPool(采用同步阻塞队列装任务，队列中有任务则启动新线程执行，没任务就阻塞)
public static ExecutorService newCachedThreadPool(){
                    return new ThreadPoolExecutor(0,//初始为0个线程
                    Integer.MAX_VALUE,//可以启动无限多线程
                    60L, TimeUnit.SECONDS,//60秒空闲则结束
                    new SynchronousQueue());//同步阻塞队列，有任务马上开新线程执行（容量用于为0）
}

//SingleThreadPool
    return new ThreadPoolExecutor(1,//初始线程数为1
                1,//最大线程数为1
                 0L, TimeUnit.SECONDS,//一旦启动线程池，线程永远不消失
                 new LinkedBlockingQueue());//链表阻塞队列
}

//ScheduledThreadPool
    public newScheduledThreadPool(int corePoolSize){
                    super(corePoolSize,//初始线程数自定义
                    Integer.MAX_VALUE,//无限多线程数
                    0, NANOSECONDS,//一旦启动线程池，线程永远不消失
                    new DelayedWorkQueue());//延时阻塞队列，隔一段时间执行一次任务
}