4种jdk自带的常用线程池简单介绍

 XML Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

package com.lyzx.restdy.thread_pool;

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

import org.junit.Test;

public class AllPool {
    
    /**
     * 1、具有缓冲的线程池
     *  来一个任务启动一个线程，线程数量没有上线(如果线程空闲60s则系统自动kill该线程)，除非系统资源耗完
     * 2、固定线程数的线程池
     *  一个任务分配一个线程，当任务数大于N时这些任务就进入到一个阻塞队列里(BlockingQueue)
     *  一旦有空闲线程就从这个队列里面取出来执行
     * 3、单线程线程池，这个线程池里面只有一个线程，每一个进来的任务都在队列里面严格按照顺序执行
     *  这个线程池非常适合做对于执行顺序有严格要求的任务
     */
    @Test
    public void test1(){
        //1、
        //ExecutorService pool = Executors.newCachedThreadPool();
        
        //2、
        //ExecutorService pool = Executors.newFixedThreadPool(6);
        
        //3、
        ExecutorService pool = Executors.newSingleThreadExecutor();
        System.out.println(pool.getClass().getName());
        for(int i=0;i<10;i++){
            pool.submit(new Thread(new X()));
            pool.submit(new Thread(new Y()));
        }
        
        //调用这个方法后，线程池会等到所有任务都执行完后再结束
        pool.shutdown();
    }
    
    
    /**
     * 具有定时任务的线程池
     * 
     */
    @Test
    public void test2(){
        CountDownLatch latch = new CountDownLatch(11);
        
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
        for(int i=0;i<10;i++){
            ses.schedule(new Thread(new X()),1,TimeUnit.MILLISECONDS);
        }
        
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    
}


class X implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"-----"+i);
        }
    }
}

class Y implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("=================================="+Thread.currentThread().getName());
        }
    }
}