adroid線程池的運用

package com.cenzr.manager;

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

/**
 * 管理線程池
 */
public class ThreadManager {
	private ThreadManager() {

	}

	private static ThreadManager instance = new ThreadManager();
	private ThreadPoolProxy longPool;
	private ThreadPoolProxy shortPool;

	public static ThreadManager getInstance() {
		return instance;
	}

	// 聯網比較耗時
	// cpu的核數*2+1
	public synchronized ThreadPoolProxy createLongPool() {
		if (longPool == null) {
			longPool = new ThreadPoolProxy(5, 5, 5000L);
		}
		return longPool;
	}
	// 操作本地文件
	public synchronized ThreadPoolProxy createShortPool() {
		if(shortPool==null){
			shortPool = new ThreadPoolProxy(3, 3, 5000L);
		}
		return shortPool;
	}

	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;

		}
		/**
		 * 執行任務
		 * @param runnable
		 */
		public void execute(Runnable runnable) {
			if (pool == null) {
				// 創建線程池
				/*
				 * 1. 線程池裏面管理多少個線程2. 如果排隊滿了, 額外的開的線程數3. 如果線程池沒有要執行的任務 存活多久4.
				 * 時間的單位 5 如果 線程池裏管理的線程都已經用了,剩下的任務 臨時存到LinkedBlockingQueue對象中 排隊
				 */
				pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
						time, TimeUnit.MILLISECONDS,
						new LinkedBlockingQueue<Runnable>(10));
			}
			pool.execute(runnable); // 調用線程池 執行異步任務
		}
		/**
		 * 取消任務
		 * @param runnable
		 */
		public void cancel(Runnable runnable) {
			if (pool != null && !pool.isShutdown() && !pool.isTerminated()) {
				pool.remove(runnable); // 取消異步任務
			}
		}
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 創建線程池,執行任務,提交任務
 */
public class ThreadPoolProxy {
	ThreadPoolExecutor	mExecutor;			// 只需創建一次
	int					mCorePoolSize;
	int					mMaximumPoolSize;
	long				mKeepAliveTime;

	public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long keepAliveTime) {
		super();
		mCorePoolSize = corePoolSize;
		mMaximumPoolSize = maximumPoolSize;
		mKeepAliveTime = keepAliveTime;
	}

	private ThreadPoolExecutor initThreadPoolExecutor() {//雙重檢查加鎖
		if (mExecutor == null) {
			synchronized (ThreadPoolProxy.class) {
				if (mExecutor == null) {
					TimeUnit unit = TimeUnit.MILLISECONDS;
					BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();// 無界隊列
					ThreadFactory threadFactory = Executors.defaultThreadFactory();
					RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();// 丟棄任務並拋出RejectedExecutionException異常。
					mExecutor = new ThreadPoolExecutor(//
							mCorePoolSize,// 核心的線程數
							mMaximumPoolSize,// 最大的線程數
							mKeepAliveTime, // 保持時間
							unit, // 保持時間對應的單位
							workQueue,// 緩存隊列/阻塞隊列
							threadFactory, // 線程工廠
							handler// 異常捕獲器
					);
				}
			}
		}
		return mExecutor;
	}

	/**執行任務*/
	public void execute(Runnable task) {
		initThreadPoolExecutor();
		mExecutor.execute(task);
	}

	/**提交任務*/
	public Future<?> submit(Runnable task) {
		initThreadPoolExecutor();
		return mExecutor.submit(task);
	}

	/**移除任務*/
	public void removeTask(Runnable task) {
		initThreadPoolExecutor();
		mExecutor.remove(task);
	}
}