亲宝软件园·资讯

展开

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

DavenPortChen. 人气:0
想了解详解什么是Java线程池的拒绝策略?的相关内容吗,DavenPortChen.在本文为您仔细讲解线程池的拒绝策略的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java线程池的拒绝策略,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());
                }
            });
        }
    }
}

加载全部内容

相关教程
猜你喜欢
用户评论