前言

昨晚12:00執行自動化測試指令碼時遇到了java.util.concurrent.RejectedExecutionException這個異常，從異常名稱裡很容易分析出是提交的任務被執行緒池拒絕了。檢視原始碼發現是在Activity裡，AsyncTask是在自定義的執行緒池的執行的，但是onDestory函式裡卻是先顯示呼叫了執行緒池的shutdown方法，然後才是AsyncTask的cancel操作，因此可能導致任務被拒絕。

ThreadPoolExecutor

一個ExecutorService，它使用可能的幾個執行緒池之一執行每個提交的任務，通常使用Executors工廠方法配置，但是檢視原始碼，發現工廠方法也是統一呼叫了ThreadPoolExecutor類，以為例，原始碼如下：

public class Executors {
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }
}
 

雖然我一直認同程式設計師應使用較為方便的Executors工廠方法Executors.newCachedThreadPool() （無界執行緒池，可以進行自動執行緒回收）、Executors.newFixedThreadPool(int)（固定大小執行緒池）和Executors.newSingleThreadExecutor()（單個後臺執行緒），但是通過原始碼我們可以發現最後他們均呼叫了ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) 方法，因此我們在分析java.util.concurrent.RejectedExecutionException之前，需要深入學習一下ThreadPoolExecutor的使用。

核心池和最大池的大小

TreadPoolExecutor將根據corePoolSize和maximumPoolSize設定的邊界自動調整池大小。當新任務在方法execute(java.lang.Runnable)中提交時，如果執行的執行緒少於corePoolSize，則建立新執行緒來處理請求，即使其他輔助執行緒是空閒的。如果執行的執行緒多於corePoolSize而少於maximumPoolSize，則僅當佇列滿時才建立新的執行緒。如果設定的corePoolSize和maximumPoolSize相同，則建立了固定大小的執行緒池。如果將maximumPoolSize設定為基本的無界值（如Integer.MAX_VALUE)，則允許執行緒池適應任意數量的併發任務。

保持活動時間

如果池中當前有多於corePoolSize的執行緒，則這些多出的執行緒在空閒時間超過keepAliveTime時將會終止。

排隊

所有BlockingQueue都可用於傳輸和保持提交的任務。可以使用此佇列與池大小進行互動：

• 如果執行的執行緒少於corePoolSize，則Executor始終首選新增新的執行緒，而不進行排隊。
• 如果執行的執行緒等於或多於corePoolSize，則Executor始終首選將請求加入佇列，而不新增新的執行緒。
• 如果無法將請求加入佇列，則建立新的執行緒，除非建立此執行緒超出maximumPoolSize，在這種情況下，任務將被拒絕（丟擲RejectedExecutionException）。

排隊有三種通用策略：

1. 直接提交。工作佇列的預設選項是synchronousQueue，它將任務直接提交給執行緒而不保持它們。在此，如果不存在可用於立即執行任務的執行緒，則試圖把任務加入佇列將失敗，因此會構造一個新的執行緒。此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。直接提交通常要求無界maximumPoolSizes以避免拒絕新提交的任務。當命令以超過佇列所能處理的平均數連續到達時，此策略允許無界執行緒具有增加的可能性。
2. 無界佇列。使用無界佇列（例如，不具有預定義容量的LinkedBlockingQueue）將導致在所有corePoolSize執行緒都忙時新任務在佇列中等待。這樣，建立的執行緒就不會超過corePoolSize（因此，maximumPoolSize的值也就無效了）。
3. 有界佇列。當使用有限的maximumPoolSizes時，有界佇列（如ArrayBlockingQueue）有助於防止資源耗盡，但是可能較難調整和控制。佇列大小和最大池大小可能需要相互折衷：使用大型佇列和小型池可以最大限度的降低CPU使用率、作業系統資源和上下文切換開銷，但是可能導致人工降低吞吐量。如果任務頻繁阻塞，則系統可能為超過您許可的更多執行緒安排時間，使用小型佇列通常要求較大的池大小，CPU使用率較高，但是可能遇到不可接受的排程開銷，這樣可會降低吞吐量。

終止

程式不再引用的池沒有剩餘執行緒會自動shutdown。如果希望確保回收取消引用的池（即使使用者忘記呼叫shutdown()），則必須安排未使用的執行緒最終終止。

分析

通過對ThreadPoolExecutor類分析，引發java.util.concurrent.RejectedExecutionException主要有兩種原因：1. 執行緒池顯示的呼叫了shutdown()之後，再向執行緒池提交任務的時候，如果你配置的拒絕策略是ThreadPoolExecutor.AbortPolicy的話，這個異常就被會丟擲來。2. 當你的排隊策略為有界佇列，並且配置的拒絕策略是ThreadPoolExecutor.AbortPolicy，當執行緒池的執行緒數量已經達到了maximumPoolSize的時候，你再向它提交任務，就會丟擲ThreadPoolExecutor.AbortPolicy異常。

顯示關閉掉執行緒池

這一點很好理解。比如說，你向一個倉庫去存放貨物，一開始，倉庫管理員把門給你打開了，你放了第一件商品到倉庫裡，但是當你放好出去後，有人把倉庫門關了，那你下次再來存放物品時，你就會被拒絕。示例程式碼如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class TextExecutor {
	public ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);
	public ExecutorService cachedExecutorService = Executors.newCachedThreadPool();
	public ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();
	
	public void testExecutorException() {
		for (int i = 0; i < 10; i ++) {
			fixedExecutorService.execute(new SayHelloRunnable());
			fixedExecutorService.shutdown();
		}
	}
	
	private class SayHelloRunnable implements Runnable {

		@Override
		public void run() {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				System.out.println("hello world!");
			}
			
		}
	}
	
	public static void main(String[] args) {
		TextExecutor testExecutor = new TextExecutor();
		testExecutor.testExecutorException();
	}
}

解決方案

1. 不要顯示的呼叫shutdown方法，例如Android裡，只有你在Destory方法裡cancel掉AsyncTask，則執行緒池裡沒有活躍執行緒會自己回收自己。2. 呼叫執行緒池時，判斷是否已經shutdown，通過API方法isShutDown方法判斷，示例程式碼：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class TextExecutor {
	public ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);
	public ExecutorService cachedExecutorService = Executors.newCachedThreadPool();
	public ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();
	
	public void testExecutorException() {
		for (int i = 0; i < 10; i ++) {
			// 增加isShutdown()判斷
			if (!fixedExecutorService.isShutdown()) {
				fixedExecutorService.execute(new SayHelloRunnable());
			}
			fixedExecutorService.shutdown();
		}
	}
	
	private class SayHelloRunnable implements Runnable {

		@Override
		public void run() {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				System.out.println("hello world!");
			}
			
		}
	}
	
	public static void main(String[] args) {
		TextExecutor testExecutor = new TextExecutor();
		testExecutor.testExecutorException();
	}
}

執行緒數量超過maximumPoolSize

示例程式碼裡使用了自定義的ExecutorService，可以復現這種問題：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class TextExecutor {
	public ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);
	public ExecutorService cachedExecutorService = Executors.newCachedThreadPool();
	public ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();
	public ExecutorService customerExecutorService = new ThreadPoolExecutor(3, 5, 0, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
	
	public void testExecutorException() {
		for (int i = 0; i < 10; i ++) {
			// 增加isShutdown()判斷
			if (!fixedExecutorService.isShutdown()) {
				fixedExecutorService.execute(new SayHelloRunnable());
			}
			fixedExecutorService.shutdown();
		}
	}
	
	public void testCustomerExecutorException() {
		for (int i = 0; i < 100; i ++) {
			customerExecutorService.execute(new SayHelloRunnable());
		}
	}
	
	private class SayHelloRunnable implements Runnable {

		@Override
		public void run() {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				System.out.println("hello world!");
			}
			
		}
	}
	
	public static void main(String[] args) {
		TextExecutor testExecutor = new TextExecutor();
		testExecutor.testCustomerExecutorException();;
	}
}

解決方案

1. 儘量調大maximumPoolSize，例如設定為Integer.MAX_VALUE

	public ExecutorService customerExecutorService = new ThreadPoolExecutor(3, Integer.MAX_VALUE, 0, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());

2. 使用其他排隊策略，例如LinkedBlockingQueue

<span style="white-space:pre">	</span>public ExecutorService customerExecutorService = new ThreadPoolExecutor(3, 5, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());