【学习】线程池：线程池中的四个任务拒绝策略的区别

沐子·李

已于 2022-02-22 22:35:35 修改

阅读量242

点赞数 2

分类专栏：线程池文章标签：学习 java 开发语言线程池

于 2022-02-22 22:28:06 首次发布

本文链接：https://blog.csdn.net/u010328311/article/details/123078755

版权

线程池专栏收录该内容

5 篇文章 0 订阅

订阅专栏

线程池：系列四

线程池中的四个任务拒绝策略的区别
参考地址

线程池中的四个任务拒绝策略的区别

在这里插入图片描述

DiscardPolicy

直接丢弃任务
首先创建任务类

/**
 * @Description 任务类
 * @ClassName Task
 * @Date 2022/2/22 21:54
 **/
public class Task implements Runnable{

    private final int index;

    public Task(int index){
        this.index = index;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName()+" "+index);
    }
}

创建线程池执行任务

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description 线程池拒绝策略
 * DiscardPolicy 直接丢弃任务
 * CallerRunsPolicy 使用调用者线程直接执行被拒绝的任务
 * AbortPolicy 默认的拒绝策略，抛出RejectedExecutionException异常
 * DiscardOldestPolicy 丢弃处于任务队列头部的任务，添加被拒绝的任务
 * @ClassName ThreadPool06
 * @Date 2022/2/22 22:05
 **/
public class ThreadPool06 {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1,1,0L, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(1),
            new ThreadPoolExecutor.DiscardPolicy());// 直接丢弃任务
        try {
            threadPool.execute((new Task(1)));
            threadPool.execute((new Task(2)));
            threadPool.execute((new Task(3)));
        }catch (RejectedExecutionException e){
            e.printStackTrace();
        }finally {
            // 关闭线程池
            threadPool.shutdown();
        }
    }
}

输出结果

CallerRunsPolicy

使用调用者线程直接执行被拒绝的任务
拒绝策略改为CallerRunsPolicy

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description 线程池拒绝策略
 * DiscardPolicy 直接丢弃任务
 * CallerRunsPolicy 使用调用者线程直接执行被拒绝的任务
 * AbortPolicy 默认的拒绝策略，抛出RejectedExecutionException异常
 * DiscardOldestPolicy 丢弃处于任务队列头部的任务，添加被拒绝的任务
 * @ClassName ThreadPool06
 * @Date 2022/2/22 22:05
 **/
public class ThreadPool06 {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1,1,0L, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(1),
                new ThreadPoolExecutor.CallerRunsPolicy()); // 使用调用者线程直接执行被拒绝的任务
        try {
            threadPool.execute((new Task(1)));
            threadPool.execute((new Task(2)));
            threadPool.execute((new Task(3)));
        }catch (RejectedExecutionException e){
            e.printStackTrace();
        }finally {
            // 关闭线程池
            threadPool.shutdown();
        }
    }
}

输出结果

AbortPolicy

默认的拒绝策略，抛出RejectedExecutionException异常
拒绝策略改为AbortPolicy

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description 线程池拒绝策略
 * DiscardPolicy 直接丢弃任务
 * CallerRunsPolicy 使用调用者线程直接执行被拒绝的任务
 * AbortPolicy 默认的拒绝策略，抛出RejectedExecutionException异常
 * DiscardOldestPolicy 丢弃处于任务队列头部的任务，添加被拒绝的任务
 * @ClassName ThreadPool06
 * @Date 2022/2/22 22:05
 **/
public class ThreadPool06 {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1,1,0L, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(1),
                new ThreadPoolExecutor.AbortPolicy());// 默认的拒绝策略，抛出RejectedExecutionException异常
        try {
            threadPool.execute((new Task(1)));
            threadPool.execute((new Task(2)));
            threadPool.execute((new Task(3)));
        }catch (RejectedExecutionException e){
            e.printStackTrace();
        }finally {
            // 关闭线程池
            threadPool.shutdown();
        }
    }
}

输出结果

DiscardOldestPolicy

丢弃处于任务队列头部的任务，添加被拒绝的任务

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description 线程池拒绝策略
 * DiscardPolicy 直接丢弃任务
 * CallerRunsPolicy 使用调用者线程直接执行被拒绝的任务
 * AbortPolicy 默认的拒绝策略，抛出RejectedExecutionException异常
 * DiscardOldestPolicy 丢弃处于任务队列头部的任务，添加被拒绝的任务
 * @ClassName ThreadPool06
 * @Date 2022/2/22 22:05
 **/
public class ThreadPool06 {

    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1,1,0L, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>(2),
                new ThreadPoolExecutor.DiscardOldestPolicy()); // 丢弃处于任务队列头部的任务，添加被拒绝的任务
        try {
            threadPool.execute((new Task(1)));
            threadPool.execute((new Task(2)));
            threadPool.execute((new Task(3)));
            threadPool.execute((new Task(4)));
        }catch (RejectedExecutionException e){
            e.printStackTrace();
        }finally {
            // 关闭线程池
            threadPool.shutdown();
        }
    }
}