多线程处理策略分析

1、AbortPolicy：它是默认的策略，处理程序遭到拒绝将抛出运行时 RejectedExecutionException，并且丢弃任务。

public class Test {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,2, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(1),new ThreadPoolExecutor.AbortPolicy());
        
        for(int i=0;i<5;i++){
            final int j=i;
            Thread.sleep(1000);
            executor.execute(new Thread(){
                @Override
                public void run(){
                    try {
                        //此处业务逻辑执行代码
                        System.out.println(j);
                        Thread.sleep(1000*10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

分析：corePoolSize=1，maximumPoolSize=2，LinkedBlockingQueue=1

第1次循环：j=0，打印0

第2次循环：j=1，任务添加到队列，不打印。

第3次循环：j=2，队列已满，根据maximumPoolSize创建一条线程，打印2

第4次循环：j=3，队列已满，并且线程池中无空闲线程。抛出异常，遗弃任务。

第5次循环：不执行

此时4次循环已经结束（注意是4次循环），但是队列中还有一条线程任务还未执行，10秒后，空闲线程从队列中取出任务并且执行任务，最后打印1

2、CallerRunsPolicy：当Queue的队列满了并且线程数达到了maximumPoolSize的值，并且没有空闲线程的情况下，其他的任务会被主线程调用。并且它既不会丢弃任务，也不会抛出任何异常，它会把任务推回到调用者那里去,以此缓解任务流,。

public class Test {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,2, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(1),new ThreadPoolExecutor.CallerRunsPolicy());
        
        for(int i=0;i<5;i++){
            final int j=i;
            Thread.sleep(1000);
            executor.execute(new Thread(){
                @Override
                public void run(){
                    try {
                        //此处业务逻辑执行代码
                        if(j>=3){
                            System.out.println("主线程在执行...");
                        }else{
                            System.out.println(j);
                            Thread.sleep(1000*10);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

分析：corePoolSize=1，maximumPoolSize=2，LinkedBlockingQueue=1

第1次循环：j=0，打印0

第2次循环：j=1，任务添加到队列，不打印。

第3次循环：j=2，队列已满，根据maximumPoolSize创建一条线程，打印2

第4次循环：j=3，队列已满，并且线程池中无空闲线程。打印主线程在执行...

第5次循环：j=4，队列已满，并且线程池中无空闲线程。打印主线程在执行...

此时5次循环已经结束，但是队列中还有一条线程任务还未执行，10秒后，空闲线程从队列中取出任务并且执行任务，最后打印1

3、DiscardPolicy：它默认会放弃这个任务，不能执行的任务将被删除，丢弃任务，只不过他不抛出异常

public class Test {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,2, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(1),new ThreadPoolExecutor.DiscardPolicy());
        
        for(int i=0;i<5;i++){
            final int j=i;
            Thread.sleep(1000);
            executor.execute(new Thread(){
                @Override
                public void run(){
                    try {
                        //此处业务逻辑执行代码
                        System.out.println(j);
                        Thread.sleep(1000*10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

分析：corePoolSize=1，maximumPoolSize=2，LinkedBlockingQueue=1

第1次循环：j=0，打印0

第2次循环：j=1，任务添加到队列，不打印。

第3次循环：j=2，队列已满，根据maximumPoolSize创建一条线程，打印2

第4次循环：j=3，队列已满，并且线程池中无空闲线程。遗弃任务。

第5次循环：j=4，队列已满，并且线程池中无空闲线程。遗弃任务。

此时5次循环已经结束，但是队列中还有一条线程任务还未执行，10秒后，空闲线程从队列中取出任务并且执行任务，最后打印1

4、DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）

public class Test {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,2, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(1),new ThreadPoolExecutor.DiscardOldestPolicy());
        
        for(int i=0;i<5;i++){
            final int j=i;
            Thread.sleep(1000);
            executor.execute(new Thread(){
                @Override
                public void run(){
                    try {
                        //此处业务逻辑执行代码
                        System.out.println(j);
                        Thread.sleep(1000*10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

分析：corePoolSize=1，maximumPoolSize=2，LinkedBlockingQueue=1

第1次循环：j=0，打印0

第2次循环：j=1，任务添加到队列，不打印。

第3次循环：j=2，队列已满，根据maximumPoolSize创建一条线程，打印2

第4次循环：j=3，队列已满，并且线程池中无空闲线程。删除队列头部任务“1”，将自己("3")添加进去。

第5次循环：j=4，队列已满，并且线程池中无空闲线程。删除队列头部任务“3”，将自己("4")添加进去。

此时5次循环已经结束，但是队列中还有一条线程任务还未执行，10秒后，空闲线程从队列中取出任务并且执行任务，最后打印4