詳解什么是Java線程池的拒絕策略？

更新時間：2021年05月26日 15:21:12 作者：DavenPortChen.

今天給大家總結一下線程池的拒絕策略,文中有非常詳細的介紹及代碼示例,對正在學習java的小伙伴們有很好地幫助,需要的朋友可以參考下

一、拒絕策略

（JDK提供了4種，另外也可以自定義拒絕策略，因此總共有5種。）
線程池中的線程已經(jīng)用完了，無法繼續(xù)為新任務服務，同時，等待隊列也已經(jīng)排滿了，再也塞不下新任務了。這時候我們就需要拒絕策略機制合理的處理這個問題。

JDK 內(nèi)置的拒絕策略如下：

1.AbortPolicy ：直接拋出異常，阻止系統(tǒng)正常運行。

2.CallerRunsPolicy ：只要線程池未關閉，該策略直接在調(diào)用者線程中，運行當前被丟棄的任務。顯然這樣做不會真的丟棄任務，但是，任務提交線程的性能極有可能會急劇下降。

3.DiscardPolicy ：該策略默默地丟棄無法處理的任務，不予任何處理。如果允許任務丟失，這是最好的一種方案。

4.DiscardOldestPolicy ：丟棄最老的一個請求，也就是即將被執(zhí)行的一個任務，并嘗試再次提交當前任務。

以上內(nèi)置拒絕策略均實現(xiàn)了 RejectedExecutionHandler 接口，若以上策略仍無法滿足實際需要，完全可以自己擴展 RejectedExecutionHandler 接口。

1.1 AbortPolicy（默認拒絕策略）

(也可以沒有new ThreadPoolExecutor.AbortPolicy() 這個參數(shù) ，隱式的默認拒絕策略)

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


public class ThreadDemo58 {
    public static void main(String[] args) {

        // 創(chuàng)建線程池
        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（使用調(diào)用線程池的線程來執(zhí)行任務）

(即使用主線程來執(zhí)行任務)

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 {

        // 創(chuàng)建線程池
        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 {

        // 創(chuàng)建線程池
        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 {

        // 創(chuàng)建線程池
        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 {

        // 創(chuàng)建線程池
        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("執(zhí)行了自定義拒絕策略");
                    }
                });
        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());
                }
            });
        }
    }
}

到此這篇關于詳解什么是線程池的拒絕策略？的文章就介紹到這了,更多相關線程池的拒絕策略內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: