线程池

线程池指的就是将多个线程封装到一起进行操作。

生活场景：功能模块开发，10人团队，3天完成。10人的团队就是线程池。

可能会有以下几种情景：

1、工作量大，有多少人要多少人，直至项目完成 // 无限量

2、工作量大，必须要求10人 // 定长

3、工作量大，只要求1人 // 单线程

 

普通的执行线程池：java.util.concurrent.ExecutorService;

调度线程池：java.util.concurrent.ScheduledExecutorService;

 

线程池的创建可以利用 java.util.concurrent.Executors 类来完成，有如下几个方法：

1.创建无大小限制的线程池：public static ExecutorService newCachedThreadPool()

2.创建固定大小的线程池：public static ExecutorService newFixedThreadPool(int nThreads)

3.单线程池：public static ScheduledExecutorService newSingleThreadScheduledExecutor()

4.创建线程定时调度池：public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

/***
 * 线程池 
 *
 */
public class Test06 {
    public static void main(String[] args) {
//        getNewSingleThreadExecutor();
//        getNewFixedThreadPool();
        getNewScheduledThreadPool();
    }
    
    //无限制大小的线程池
    public static void getNewCachedThreadPool(){
        //现在创建了一个线程池模型，但是里面现在没有线程 （无大小限制的）
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            int x = i;
            //如果，在这里不等待，会创建好多线程，线程等待后，只会创建一个线程。
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            executorService.submit(() ->{
               System.out.println(Thread.currentThread().getName() + "、x = " + x); 
            });
        }
        //关闭线程池
        executorService.shutdown();
    }
    
    
    public static void getNewSingleThreadExecutor(){
        //创建单线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            int x = i;
            executorService.submit(() ->{
               System.out.println(Thread.currentThread().getName() + "、x = " + x); 
            });
        }
        executorService.shutdown();
    }
    
    public static void getNewFixedThreadPool(){
        //创建固定大小单线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            int x = i;
            executorService.submit(() ->{
                System.out.println(Thread.currentThread().getName() + "、x = " + x); 
            });
        }
        executorService.shutdown();
    }
    
    
    
    public static void getNewScheduledThreadPool(){
        //创建具有一个线程大小的定时调度线程池
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        for (int i = 0; i < 10; i++) {
            int x = i;
            /***
             * 调度方法
             * 参数（方法，多长时间后开始，多长时间循环一次，时间单位）
             */
            executorService.scheduleAtFixedRate(() ->{
                System.out.println(Thread.currentThread().getName() + "、x = " + x); 
            }, 3, 2, TimeUnit.SECONDS);
        }
        //现在得调度方法时3秒后执行，没两秒循环一次，会永远的执行下去，所以此处不能关闭。
        //executorService.shutdown();
    }