并发编程[5] —线程池

Executor框架

Executor框架基本使用流程

一、什么是线程池？为什么要用线程池？

1、降低资源的消耗。降低线程创建和销毁的资源消耗；
2、提高响应速度：线程的创建时间为T1，执行时间T2,销毁时间T3，免去T1和T3的时间
3、提高线程的可管理性。
实现一个我们自己的线程池
1、线程必须在池子已经创建好了，并且可以保持住，要有容器保存多个线程；
2、线程还要能够接受外部的任务，运行这个任务。容器保持这个来不及运行的任务.

二、JDK中的线程池和工作机制

2.1 线程池的创建和参数含义

ThreadPoolExecutor，jdk所有线程池实现的父类
各个参数含义
int corePoolSize ：线程池中核心线程数，< corePoolSize ，就会创建新线程，= corePoolSize ，这个任务就会保存到BlockingQueue，如果调用prestartAllCoreThreads（）方法就会一次性的启动corePoolSize 个数的线程。
int maximumPoolSize, 允许的最大线程数，BlockingQueue也满了，< maximumPoolSize时候就会再次创建新的线程
long keepAliveTime, 线程空闲下来后，存活的时间，这个参数只在> corePoolSize才有用
TimeUnit unit, 存活时间的单位值
BlockingQueue workQueue, 保存任务的阻塞队列
ThreadFactory threadFactory, 创建线程的工厂，给新建的线程赋予名字
RejectedExecutionHandler handler ：饱和策略
AbortPolicy ：直接抛出异常，默认；
CallerRunsPolicy：用调用者所在的线程来执行任务
DiscardOldestPolicy：丢弃阻塞队列里最老的任务，队列里最靠前的任务
DiscardPolicy ：当前任务直接丢弃
实现自己的饱和策略，实现RejectedExecutionHandler接口即可
提交任务
execute(Runnable command) 不需要返回
Future submit(Callable task) 需要返回

关闭线程池
shutdown(),shutdownNow();
shutdownNow():设置线程池的状态，还会尝试停止正在运行或者暂停任务的线程
shutdown()设置线程池的状态，只会中断所有没有执行任务的线程
工作机制

合理配置线程池
根据任务的性质来：计算密集型（CPU），IO密集型，混合型
计算密集型：加密，大数分解，正则…….， 线程数适当小一点，最大推荐：机器的Cpu核心数+1，为什么+1，防止页缺失，(机器的Cpu核心=Runtime.getRuntime().availableProcessors()😉
IO密集型：读取文件，数据库连接，网络通讯, 线程数适当大一点，机器的Cpu核心数*2,
混合型：尽量拆分，IO密集型>>计算密集型，拆分意义不大，IO密集型~计算密集型
队列的选择上，应该使用有界，无界队列可能会导致内存溢出，OOM
预定义的线程池
FixedThreadPool
创建固定线程数量的，适用于负载较重的服务器，使用了无界队列
SingleThreadExecutor
创建单个线程，需要顺序保证执行任务，不会有多个线程活动，使用了无界队列
CachedThreadPool
会根据需要来创建新线程的，执行很多短期异步任务的程序，使用了SynchronousQueue
WorkStealingPool（JDK7以后）
基于ForkJoinPool实现
ScheduledThreadPoolExecutor
需要定期执行周期任务，Timer不建议使用了。
newSingleThreadScheduledExecutor：只包含一个线程，只需要单个线程执行周期任务，保证顺序的执行各个任务
newScheduledThreadPool 可以包含多个线程的，线程执行周期任务，适度控制后台线程数量的时候
方法说明：
schedule：只执行一次，任务还可以延时执行
scheduleAtFixedRate：提交固定时间间隔的任务
scheduleWithFixedDelay：提交固定延时间隔执行的任务
两者的区别：
scheduleAtFixedRate任务超时：
规定60s执行一次，有任务执行了80S，下个任务马上开始执行
第一个任务 时长 80s，第二个任务20s，第三个任务 50s
第一个任务第0秒开始，第80S结束；
第二个任务第80s开始，在第100秒结束；
第三个任务第120s秒开始，170秒结束
第四个任务从180s开始

参加代码：ScheduleWorkerTime类，执行效果如图：

package Interview;

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

/**
 * 线程池实现原理:
 * 提交一个任务到线程池中，线程池的处理流程：
 * <p>
 * 1、判断线程池里的核心线程是否都在执行任务，
 * 如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。
 * 2、如果核心线程都在执行任务，线程池判断工作队列是否已满，
 * 如果工作队列没有满，则将新提交的任务存储在这个工作队列里。
 * 3、如果工作队列满了，就会判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。
 * 如果已经满了，则交给拒绝策略来处理这个任务。
 */
public class ThreadPoolTest {

    public static void main(String[] args) {
        //newFixedThreadPoolTest();
        //newCachedThreadPoolTest();
        //newSingleThreadExecutorTest();
        newScheduledThreadPoolTest();

    }


    /**
     * 创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，
     * 如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。
     */
    private static void newFixedThreadPoolTest() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()
                            + "正在被执行");
                    try {
                        Thread.sleep(2000);
                        System.out.println("休眠2秒");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }


    /**
     * 创建一个可缓存的线程池。这种类型的线程池特点是：
     * 工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
     * 如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。
     * 终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
     * <p>
     * 线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程
     */
    private static void newCachedThreadPoolTest() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            try {
                // sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 打印正在执行的缓存线程信息
                    System.out.println(Thread.currentThread().getName()
                            + "正在被执行");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }


    /**
     * 创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，
     * 如果这个线程异常结束，会有另一个取代它，保证顺序执行。
     * 单工作线程最大的特点是可保证顺序地执行各个任务，
     * 并且在任意给定的时间不会有多个线程是活动的 。
     */
    private static void newSingleThreadExecutorTest() {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 20; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        //结果依次输出，相当于顺序执行各个任务
                        System.out.println(Thread.currentThread().getName() + "正在被执行,打印的值是:" + index);
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }


    /**
     * 创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。
     */
    private static void newScheduledThreadPoolTest() {
        //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
/*

        // 延迟一秒后每3秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Calendar.getInstance().getTimeInMillis()/1000);
                System.out.println("每3秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
*/

        //延迟1秒执行
        System.out.println(Calendar.getInstance().getTimeInMillis() / 1000);
        scheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println(Calendar.getInstance().getTimeInMillis() / 1000);
                System.out.println("延迟1秒执行");

            }
        }, 1, TimeUnit.SECONDS);

    }

}