author : TaoYuanming of the Western Wei Dynasty
Blog : https://blog.springlearn.cn/

TaoYuanming of the Western Wei Dynasty
Don't laugh at the young Jianghu dream , Who doesn't dream of Jianghu

Refusal strategy

The rejection strategy is that the task can't be implemented , Then you need to tell the program , How to refuse to perform other tasks

In the actual development scenario , Basic use JDK With its own strategy, daily development can be completed , But as a programmer, you must know . Let's talk about it JDK What threading strategies are included

public interface RejectedExecutionHandler {
    
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

Four rejection strategies

ThreadPoolExecutor Class is built-in 4 Middle refusal strategy , Let's analyze... One by one

1. CallerRunsPolicy

Perform the task directly , If the thread pool is closed , It doesn 't run

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

2. AbortPolicy 【 The default policy 】

Report an exception directly , Simple and crude

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

3. DiscardPolicy

Direct discarding , No information is recorded

 public static class DiscardPolicy implements RejectedExecutionHandler {
    
        public DiscardPolicy() {
     }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    
        }
    }

4. DiscardOldestPolicy

Discard an old task , And then perform the current task

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    
        public DiscardOldestPolicy() {
     }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    
            if (!e.isShutdown()) {
    
				// Retrieves and removes the head of this queue  Remove the first task , That is, the old task 
                e.getQueue().poll();
                e.execute(r);
            }
        }

analysis

The rejection strategy is actually very simple , Knowing one's own and knowing one's other will win every battle , In the scenario of multithreading and multitasking programming , We can define rejection policies according to business characteristics .
such as , When the task is full, it will , Put the task into the database , Or print to a special log , Used to recover tasks .

Finally, please pay attention , Request subscription , Thanks for reading !