執行緒池的原理

執行緒池使用來管理執行緒的，之所以稱為池，是因為其可以管理多條執行緒，所以需要用一個集合來管理執行緒，然後執行緒池是有大小的，當一個執行緒池管理的執行緒數目為計算機的cup數*2+1個的時候，效率為最高。當使用執行緒池來執行非同步任務的時候，執行緒池會先將這個任務新增到集合中，然後為其建立一個執行緒，執行緒方法中有一個while true一直在迴圈，當集合的size大於0的時候，也就是集合中有非同步任務的時候，會呼叫集合的remove方法，這個方法一方面把這個非同步任務從集合中移除掉，另一方面又拿到了這個任務。如果這個任務不為空，就可以執行了。

下面是一些原理程式碼

public
 
 class ThreadPool {

	// 定義一個集合來管理執行緒
	LinkedList<Runnable> runnables = new LinkedList<>();

	int threadCount = 3;// 定義執行緒池的容量最大為3
	// int count = 0;//定義當前的執行緒個數
	// 使用原子性的操作定義當前執行緒的個數，避免執行緒安全問題
	AtomicInteger count = new AtomicInteger(3);

	// 只能建立三個執行緒
	public void execute(Runnable runnable) {
		// 每次執行的時候都把執行緒新增到集合中
 

		// count++; 這個操作會造成執行緒的安全問題
		runnables.add(runnable);
		// 這個方法表示得到當前數值加1的值
		if (count.incrementAndGet() < 3) {
			createThread();
		}
	}

	// 定義一個建立執行緒的方法
	public void createThread() {
		new Thread() {
			public void run() {
				while (true) {
					// 先判斷集合中是否有執行緒
					if (runnables.size() > 0) {
 


						// 即從集合中移除了一個執行緒，又取出了一個非同步任務
						Runnable remove = runnables.remove();
						if (remove != null) {
							remove.run();// 如果不為空就run
						} 
						
					}else {
						// 否則就等待 wake();
					}
				}
			};
		}.start();
	}
}

執行緒池管理類

使用單例模式建立執行緒管理器物件

可以根據具體需求

管理多個執行緒池

執行緒池管理的執行緒的個數由需求決定

• 關鍵的類和方法
  • ThreadPoolExecutor 執行緒池物件
  • **pool.execute(runnable);**呼叫執行緒池，執行非同步任務
  • pool.remove(runnable); 移除一個非同步任務

/**
 * 使用單例模式建立一個執行緒管理者 管理執行緒池 管理了兩個執行緒池
 * 
 * @author Sunxin
 *
 */
public class ThreadManager {
	// 私有化構造方法
	private ThreadManager() {

	}

	// 建立一個私有的靜態的物件
	private static ThreadManager instance = new ThreadManager();
	private ThreadPoolProxy longPool;
	private ThreadPoolProxy shortPool;

	// 提供一個公有的得到該物件的方法
	public static ThreadManager getInstance() {
		return instance;
	}

	// 根據需求開啟不同的執行緒池
	// 對外提供一個建立執行緒池的方法
	// 用來處理本地檔案.保證執行緒同步
	public synchronized ThreadPoolProxy createShortPool() {
		shortPool = new ThreadPoolProxy(3, 3, 5000L);
		return shortPool;
	}

	// 處理聯網等耗時的操作的執行緒池
	public synchronized ThreadPoolProxy createLongPool() {
		longPool = new ThreadPoolProxy(3, 3, 5000L);
		return longPool;
	}

	// 執行緒池的代理物件
	// 寫一個執行緒池代理的內部類
	public class ThreadPoolProxy {
		// 執行緒池物件
		private ThreadPoolExecutor pool;
		// 執行緒池能裝的執行緒的個數
		private int corePoolSize;
		// 如果排隊滿了，額外開啟的執行緒數
		private int maximumPoolSize;
		// 存活時間
		private long time;

		// 構造
		public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long time) {
			this.corePoolSize = corePoolSize;
			this.maximumPoolSize = maximumPoolSize;
			this.time = time;
		}

		// 執行一個非同步任務
		public void execute(Runnable runnable) {
			if (pool == null) {
				// 建立執行緒池
				/**
				 * corePoolSize：執行緒池能裝的執行緒的個數 
				 * maximumPoolSize：如果排隊也滿了，額外開啟的執行緒數
				 * keepAliveTime：如果執行緒沒有要執行的任務了，該執行緒能存活多久 
				 * unit： 存活的時間單位
				 * workQueue：如果執行緒池裡面管理的執行緒都已經用了，那麼剩下的任務就存到該物件中排隊等候
				 * 
				 */
				pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, time, TimeUnit.MILLISECONDS,
						new LinkedBlockingQueue<Runnable>(10));
			}

			// 呼叫執行緒池，執行非同步任務
			pool.execute(runnable);
		}

		// 移除一個非同步任務
		public void cancle(Runnable runnable) {
			// 判斷，當該任務既不能為空，也不能崩潰，更不能停止
			if (pool != null && !pool.isShutdown() && !pool.isTerminated()) {
				// 移除
				pool.remove(runnable);
			}
		}

	}
}

最後就可以通過執行緒池管理類來建立執行緒池管理非同步的任務了，不用再去new Thread了，相當於一個執行緒的優化

ThreadManager.getInstance().createLongPool().execute(new Runnable() {

			@Override
			public void run() {
					//操作一些非同步任務
						}
					}
				});
			}
		});

這都是一些個人的理解，難免有偏差。歡迎指正