详解什么是Java线程池的拒绝策略？

拒绝策略

（jdk提供了4种，另外也可以自定义拒绝策略，因此总共有5种。）
线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。

jdk 内置的拒绝策略如下：

1.abortpolicy ： 直接抛出异常，阻止系统正常运行。

2.callerrunspolicy ： 只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极有可能会急剧下降。

3.discardpolicy ： 该策略默默地丢弃无法处理的任务，不予任何处理。如果允许任务丢失，这是最好的一种方案。

4.discardoldestpolicy ： 丢弃最老的一个请求，也就是即将被执行的一个任务，并尝试再次提交当前任务。

以上内置拒绝策略均实现了 rejectedexecutionhandler 接口，若以上策略仍无法满足实际需要，完全可以自己扩展 rejectedexecutionhandler 接口。

1.1 abortpolicy（默认拒绝策略）

(也可以没有new threadpoolexecutor.abortpolicy() 这个参数 ，隐式的默认拒绝策略)

import java.util.concurrent.linkedblockingqueue;
import java.util.concurrent.threadpoolexecutor;
import java.util.concurrent.timeunit;


public class threaddemo58 {
    public static void main(string[] args) {

        // 创建线程池
        threadpoolexecutor executor = new threadpoolexecutor(
                5, 5,
                0, timeunit.seconds,
                new linkedblockingqueue<>(5),
                new threadpoolexecutor.abortpolicy());
        for (int i = 0; i < 11; i++) {
            int finali = i;
            executor.execute(new runnable() {
                @override
                public void run() {
                    system.out.println("任务：" + finali + "，线程名：" +
                            thread.currentthread().getname());
                }
            });
        }
    }
}

1.2 callerrunspolicy（使用调用线程池的线程来执行任务 ）

(即使用主线程来执行任务)

import java.util.concurrent.linkedblockingqueue;
import java.util.concurrent.threadpoolexecutor;
import java.util.concurrent.timeunit;


public class threaddemo59 {
    public static void main(string[] args) throws interruptedexception {

        // 创建线程池
        threadpoolexecutor executor = new threadpoolexecutor(
                5, 5,
                0, timeunit.seconds,
                new linkedblockingqueue<>(5),
                new threadpoolexecutor.callerrunspolicy());
        for (int i = 0; i < 11; i++) {
            int finali = i;
            executor.execute(new runnable() {
                @override
                public void run() {
                    system.out.println("任务：" + finali + "，线程名：" +
                            thread.currentthread().getname());
                }
            });
//            thread.sleep(200);
        }

    }
}

1.3 discardpolicy （忽略新任务）

import java.util.concurrent.linkedblockingqueue;
import java.util.concurrent.threadpoolexecutor;
import java.util.concurrent.timeunit;



public class threaddemo59 {
    public static void main(string[] args) throws interruptedexception {

        // 创建线程池
        threadpoolexecutor executor = new threadpoolexecutor(
                5, 5,
                0, timeunit.seconds,
                new linkedblockingqueue<>(5),
                new threadpoolexecutor.abortpolicy());
        for (int i = 0; i < 11; i++) {
            int finali = i;
            executor.execute(new runnable() {
                @override
                public void run() {
                    system.out.println("任务：" + finali + "，线程名：" +
                            thread.currentthread().getname());
                }
            });
        }
    }
}

1.4 discardoldestpolicy（忽略老任务）

（老任务指第一个进入阻塞队列里的）

import java.util.concurrent.linkedblockingqueue;
import java.util.concurrent.threadpoolexecutor;
import java.util.concurrent.timeunit;


public class threaddemo59 {
    public static void main(string[] args) throws interruptedexception {

        // 创建线程池
        threadpoolexecutor executor = new threadpoolexecutor(
                5, 5,
                0, timeunit.seconds,
                new linkedblockingqueue<>(5),
                new threadpoolexecutor.discardoldestpolicy());
        for (int i = 0; i < 11; i++) {
            int finali = i;
            executor.execute(new runnable() {
                @override
                public void run() {
                    system.out.println("任务：" + finali + "，线程名：" +
                            thread.currentthread().getname());
                }
            });
        }
    }
}

1.5 自定义拒绝策略

import java.util.concurrent.linkedblockingqueue;
import java.util.concurrent.rejectedexecutionhandler;
import java.util.concurrent.threadpoolexecutor;
import java.util.concurrent.timeunit;


public class threaddemo60 {
    public static void main(string[] args) throws interruptedexception {

        // 创建线程池
        threadpoolexecutor executor = new threadpoolexecutor(
                5, 5,
                0, timeunit.seconds,
                new linkedblockingqueue<>(5),
                new rejectedexecutionhandler() {
                    @override
                    public void rejectedexecution(runnable r, threadpoolexecutor executor) {
                        // 自定义拒绝策略
                        system.out.println("执行了自定义拒绝策略");
                    }
                });
        for (int i = 0; i < 11; i++) {
            int finali = i;
            executor.execute(new runnable() {
                @override
                public void run() {
                    system.out.println("任务：" + finali + "，线程名：" +
                            thread.currentthread().getname());
                }
            });
        }
    }
}

到此这篇关于详解什么是线程池的拒绝策略？的文章就介绍到这了,更多相关线程池的拒绝策略内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！