详解什么是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());
                }
            });
        }
    }
}

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