java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java多线程拒绝策略

Java多线程4种拒绝策略小结

作者：皮卡冲撞

当线程池中的任务队列已满且无法再接受新的任务时,就需要采取拒绝策略来处理这种情况,本文主要介绍了Java多线程拒绝策略,包含了四种常见的拒绝策略,具有一定的参考价值,感兴趣的可以了解一下

一、简介

在Java多线程编程中，我们通常使用线程池来管理和调度任务。线程池由一组预先创建的线程组成，可以重复利用这些线程来执行多个任务，避免频繁地创建和销毁线程而带来的性能开销。

当线程池中的任务队列已满且无法再接受新的任务时，就需要采取拒绝策略来处理这种情况。拒绝策略定义了当无法再接受新的任务时如何处理这些被拒绝的任务。

Java提供了四种常见的拒绝策略：

二、AbortPolicy拒绝策略

A. 概述

AbortPolicy是ThreadPoolExecutor的默认拒绝策略，当任务无法被提交给线程池时，会直接抛出RejectedExecutionException异常。

B. 拒绝策略实现原理

实现RejectedExecutionHandler接口，在rejectedExecution方法中抛出异常。

public class AbortPolicy implements RejectedExecutionHandler {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString());
    }
}

C. 应用场景

适用于对任务提交失败要求敏感的场景，需要明确知道任务是否被接受并执行。

D. 使用示例

当线程池的任务队列和线程队列都已满的情况下执行决绝策略

public class Task implements Runnable {

    private final int index;

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

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


public class Main {

    public static void main(String[] args) {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1, 0L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1),
                new ThreadPoolExecutor.AbortPolicy());
        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拒绝策略

A. 概述

CallerRunsPolicy是一种简单的拒绝策略，当任务无法被提交给线程池时，会由提交任务的线程自己执行该任务。

B. 拒绝策略实现原理

实现RejectedExecutionHandler接口，在rejectedExecution方法中使用提交任务的线程来执行任务。

public class CallerRunsPolicy implements RejectedExecutionHandler {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

C. 应用场景

适用于对任务提交失败要求较低的场景，通过调用线程来执行任务，避免任务丢失。

D. 使用示例

public class Task implements Runnable {

    private final int index;

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

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

public class Main {

    public static void main(String[] args) {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1, 0L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(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();
        }
    }
}

在这里插入图片描述

四、DiscardPolicy拒绝策略

A. 概述

DiscardPolicy是一种简单的拒绝策略，当任务无法被提交给线程池时，会直接丢弃该任务，没有任何提示或处理。

B. 拒绝策略实现原理

实现RejectedExecutionHandler接口，在rejectedExecution方法中不做任何操作，即丢弃任务。

public class DiscardPolicy implements RejectedExecutionHandler {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        // Do nothing, discard the task
    }
}

C. 应用场景

适用于对任务提交失败不敏感的场景，对任务丢失没有特殊要求。

D. 使用示例

public class Task implements Runnable {

    private final int index;

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

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

public class Main {

    public static void main(String[] args) {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1, 0L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        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拒绝策略

A. 概述

DiscardOldestPolicy是一种拒绝策略，当任务无法被提交给线程池时，会丢弃最早的一个任务，然后尝试再次提交。

B. 拒绝策略实现原理

实现RejectedExecutionHandler接口，在rejectedExecution方法中从队列中获取最早的任务并丢弃，再次提交当前任务。

public class DiscardOldestPolicy implements RejectedExecutionHandler {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

C. 应用场景

适用于对新任务优先级比较高的场景，可以丢弃旧的任务以保证及时处理新任务。

D. 使用示例

public class Task implements Runnable {

    private final int index;

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

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

public class Main {

    public static void main(String[] args) {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1, 0L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(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();
        }
    }
}

在这里插入图片描述

六、总结

各种拒绝策略的特点和适用场景

到此这篇关于Java多线程4种拒绝策略小姐的文章就介绍到这了,更多相关Java多线程拒绝策略内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！ 

您可能感兴趣的文章:
阅读全文