Java线程池的实现原理及其在业务中的最佳实践

execute(Runnable r):没有返回值，仅仅是把一个任务提交给线程池处理
submit(Runnable r):返回值为Future类型，当任务处理完毕后，通过Future的get()方法获取返回值时候，得到的是null
submit(Runnable r,Object result):返回值为Future类型，当任务处理完毕后，通过Future的get()方法获取返回值时候，得到的是传入的第二个参数result 
shutdown():关闭线程池，不接受新任务，但是等待队列中的任务处理完毕才能真正关闭
shutdownNow():立即关闭线程池，不接受新任务，也不再处理等待队列中的任务，同时中断正在执行的线程
setCorePoolSize(int corePoolSize):设置核心线程数    setKeepAliveTime(long time, TimeUnit unit):设置线程的空闲时间    setMaximumPoolSize(int maximumPoolSize):设置最大线程数    setRejectedExecutionHandler(RejectedExecutionHandler rh):设置拒绝策略    setThreadFactory(ThreadFactory tf):设置线程工厂
beforeExecute(Thread t, Runnable r):任务执行之前的钩子函数，这是一个空函数，使用者可以继承ThreadPoolExecutor后重写这个方法，实现其中的逻辑    afterExecute(Runnable r, Throwable t):任务执行之后的钩子函数，这是一个空函数，使用者可以继承ThreadPoolExecutor后重写这个方法，实现其中的逻辑

    public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue workQueue,                              ThreadFactory threadFactory,                              RejectedExecutionHandler handler) 

1.corePoolSize:  核心线程数
2.maximumPoolSize:  最大线程数
3.keepAliveTime:  线程的空闲时间
4.unit:  空闲时间的单位（秒、分、小时等等）
5.workQueue:  等待队列
6.threadFactory:  线程工厂
7.handler:  拒绝策略
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程直接处理该任务（可能为主线程Main），保证每个任务执行完毕

public class TestThreadPool {
    /**     * 线程池     */    private static ExecutorService executor = initDefaultExecutor();
    /**     * 统一的获取线程池对象方法     */    public static ExecutorService getExecutor() {        return executor;    }
    private static final int DEFAULT_THREAD_SIZE = 16;    private static final int DEFAULT_QUEUE_SIZE = 10240;
    private static ExecutorService initDefaultExecutor() {        return new ThreadPoolExecutor(DEFAULT_THREAD_SIZE, DEFAULT_THREAD_SIZE,                300, TimeUnit.SECONDS,                new ArrayBlockingQueue<>(DEFAULT_QUEUE_SIZE),                new DefaultThreadFactory(),                new ThreadPoolExecutor.CallerRunsPolicy());    }}

public static void main(String[] args) {    test1();    test2();}
public static void test1(){
    Object obj = new Object();    System.out.println("方法一执行完成");}
public static void test2(){
    ExecutorService executorService = Executors.newFixedThreadPool(10);    executorService.execute(new Runnable() {        @Override        public void run() {            System.out.println("方法二执行完成");        }    });}

private final class Worker        extends AbstractQueuedSynchronizer        implements Runnable

public class Outer {
    private String name;
    private Inner inner;
    public int outerMethod() {        return 1;    }
    /**     * 非静态内部类     */    class Inner {
        private void innerMethod() {            //在非静态内部类中可以直接调用外部类的方法            outerMethod();        }
        private String address;    }}

class Outer$Inner {    private String address;
    Outer$Inner(Outer var1) {        this.this$0 = var1;    }
    private void innerMethod() {        this.this$0.outerMethod();    }}

public class Outer {
    private String name;
    private Inner inner;
    public int outerMethod() {        return 1;    }
    /**     * 静态内部类     */    static class Inner {
        private String address;    }}

class Outer$Inner {    private String address;
    Outer$Inner() {    }}