執行緒管理(一)AsyncTask與Thread的差別
AsycTask,做Android的應該都是熟悉的不能再熟悉了,當我們在進行耗時操作的時候,就可以使用這個了
但是有的人就在想,Thread不是也可以開一個子執行緒進行耗時操作嗎?那這兩個有什麼樣的區別呢?
那麼一起來看下AsycTask原始碼啦
public abstract class AsyncTask<Params, Progress, Result> {
private static final String LOG_TAG = "AsyncTask";
//獲取cpu可用處理器的數量,執行緒的數量為cpu*2+1比較好
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
//這裡有個建立執行緒的方法,說明AsyncTask裡面是含有Thread的
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
//建立一個Linked的佇列,先進先出
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
//建立執行緒池啦
public static final Executor THREAD_POOL_EXECUTOR
= new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
/**
* An {@link Executor} that executes tasks one at a time in serial
* order. This serialization is global to a particular process.
*/
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static final int MESSAGE_POST_RESULT = 0x1;
private static final int MESSAGE_POST_PROGRESS = 0x2;
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static InternalHandler sHandler;
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
private volatile Status mStatus = Status.PENDING;
private final AtomicBoolean mCancelled = new AtomicBoolean();
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
//建立一個空陣列雙端佇列容納16個元素的初始容量
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
//從佇列中取出最先的並執行
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
public enum Status {
/**
* Indicates that the task has not been executed yet.
*/
PENDING,
/**
* Indicates that the task is running.
*/
RUNNING,
/**
* Indicates that {@link AsyncTask#onPostExecute} has finished.
*/
FINISHED,
}
//從這裡開始使用Handler機制,用來跟主執行緒進行互動
private static Handler getHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler();
}
return sHandler;
}
}
public static void setDefaultExecutor(Executor exec) {
sDefaultExecutor = exec;
}
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//我們實現的doInBackground方法,就是在這裡呼叫的
return postResult(doInBackground(mParams));
}
};
//使用來管理執行緒的
mFuture = new FutureTask<Result>(mWorker) {
//這裡就是耗時操作完成了
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
}
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
//這裡就是向主執行緒傳送訊息
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
public final Status getStatus() {
return mStatus;
}
protected abstract Result doInBackground(Params... params);
protected void onPreExecute() {
}
@SuppressWarnings({"UnusedDeclaration"})
protected void onPostExecute(Result result) {
}
@SuppressWarnings({"UnusedDeclaration"})
protected void onProgressUpdate(Progress... values) {
}
@SuppressWarnings({"UnusedParameters"})
protected void onCancelled(Result result) {
onCancelled();
}
protected void onCancelled() {
}
public final boolean isCancelled() {
return mCancelled.get();
}
public final boolean cancel(boolean mayInterruptIfRunning) {
mCancelled.set(true);
return mFuture.cancel(mayInterruptIfRunning);
}
/**
* Waits if necessary for the computation to complete, and then
* retrieves its result.
*
* @return The computed result.
*
* @throws CancellationException If the computation was cancelled.
* @throws ExecutionException If the computation threw an exception.
* @throws InterruptedException If the current thread was interrupted
* while waiting.
*/
public final Result get() throws InterruptedException, ExecutionException {
return mFuture.get();
}
public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException {
return mFuture.get(timeout, unit);
}
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
//我們呼叫的new AsycTask(。。).execute就是呼叫執行緒池來執行非同步任務
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
private static class InternalHandler extends Handler {
public InternalHandler() {
super(Looper.getMainLooper());
}
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
}
簡單的捋一下,就是通過執行緒池建立執行緒執行非同步任務,然後通過handler機制,發信息給主執行緒,讓主執行緒知道現在是出於什麼樣的狀態
區別:1。AsycTask跟Thread的區別就是AsycTask它能管理的執行緒數量是有限的!
MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
2。AsycTask是使用了Handler機制能跟主執行緒進行互動,而Thread只是非同步操作
那麼,如果我們只是進行非同步操作不跟主執行緒進行互動,還需要使用AscyTask嗎?
如果我們需要用到很多的非同步操作,能使用AsycTask嗎?
當然就是不能拉,下一節介紹,我們自己建立一個執行緒管理器
相關推薦
執行緒管理(一)AsyncTask與Thread的差別
AsycTask,做Android的應該都是熟悉的不能再熟悉了,當我們在進行耗時操作的時候,就可以使用這個了 但是有的人就在想,Thread不是也可以開一個子執行緒進行耗時操作嗎?那這兩個有什麼樣的區別呢? 那麼一起來看下AsycTask原始碼啦 p
執行緒管理(一)執行緒的建立和執行
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:歐振聰 執行緒的建立和執行 在這個指南中,我們將學習如何在Java程式中建立和執行執行緒。與每個Java語言中的元素一樣,執行緒
android 程序/執行緒管理(一)----訊息機制的框架
一:android 程序和執行緒 程序是程式執行的一個例項。android通過4大主件,弱化了程序的概念,尤其是在app層面,基本不需要關係程序間的通訊等問題。 但是程式的本質沒有變,尤其是多工系統,以事件為驅動的軟體系統基本模式都是如下: 程式的入口一般是main: 1.初始化: 比如建立視窗,申
C#多執行緒程式設計(一)程序與執行緒
一、 程序 簡單來說,程序是對資源的抽象,是資源的容器,在傳統作業系統中,程序是資源分配的基本單位,而且是執行的基本單位,程序支援併發執行,因為每個程序有獨立的資料,獨立的堆疊空間。一個程式想要併發執行,開多個程序即可。
Android執行緒與執行緒池(一)
前言,學習安卓很久了,一直也沒有學部落格的習慣,下決心從今天開始要養成寫部落格總結學習經驗的好習慣! 一.Android中執行緒與執行緒池的簡介 在Android中執行緒主要可以分為兩大類:一個用於處理介面相關與使用者互動的執行緒-主執行緒;一個用於處理耗時任務-子執行緒
java併發學習--執行緒池(一)
關於java中的執行緒池,我一開始覺得就是為了避免頻繁的建立和銷燬執行緒吧,先建立一定量的執行緒,然後再進行復用。但是要具體說一下如何做到的,自己又說不出一個一二三來了,這大概就是自己的學習習慣流於表面,不經常深入的結果吧。所以這裡決定系統的學習一下執行緒池的相關知識。 自己稍微總結了一下,
java多執行緒系列(一):Thread、Runnable、Callable實現多執行緒的區別
實現多執行緒 java實現多執行緒的方法有三種,分別是繼承thread類,實現runnable介面,實現callable介面(call方法有返回值) /** * 繼承Thread */ public class MyThread extends Thread{ int a = 0;
java多執行緒-初探(一)
啥是多執行緒?跟程序又是啥關係? 比方說:我去洗手,洗完手去吃飯。 程序(Processor) 洗手跟吃飯是兩個程序。 執行緒(Thread) 在洗手的程序裡,我同時聽歌,還唱歌。那這裡洗手是一個程序,聽歌跟唱歌是兩個執行緒。 在吃飯的程序裡,我同時聽歌,還
多執行緒基礎(一)
最近讀了高洪巖的《Java多執行緒程式設計核心技術》一書,打算記錄下多執行緒的基礎知識點,也算對本書的一個讀後感了。目前打算分四五篇博文進行記錄。 第一篇主要是記錄執行緒的概念,建立,常用的基礎方法等。 1. 什麼是執行緒? 通常我們所說執行緒是程序的最小單位。那麼問題來了,什麼是程序呢?程序就是作業系統結構
執行緒管理(四)操作執行緒的中斷機制
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:歐振聰 操作執行緒的中斷機制 在之前的指南里,你學習瞭如何中斷執行執行緒和如何對Thread物件的中斷控制。之前例子中的機制可以
執行緒管理(九)使用本地執行緒變數
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:方騰飛 使用本地執行緒變數 併發應用的一個關鍵地方就是共享資料。這個對那些擴充套件Thread類或者實現Runnable介面的物
執行緒管理(三)執行緒的中斷
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:歐振聰 執行緒的中斷 一個多個執行緒在執行的Java程式,只有當其全部的執行緒執行結束時(更具體的說,是所有非守護執行緒結束或者
基本執行緒同步(一)引言
宣告:本文是《 Java 7 Concurrency Cookbook 》的第二章,作者: Javier Fernández González 譯者:許巧輝 校對:方騰飛 引言 在這個章節中,我們將覆蓋: 同步方法 介紹 在併發程式設計中發生的最常見的一種情況是超過一個
執行緒管理(八)線上程裡處理不受控制的異常
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:方騰飛 線上程裡處理不受控制的異常 Java裡有2種異常: 檢查異常(Checked exceptions): 這些異常必須強
執行緒管理(二)獲取和設定執行緒資訊
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:歐振聰 獲取和設定執行緒資訊 Thread類的物件中儲存了一些屬性資訊能夠幫助我們來辨別每一個執行緒,知道它的狀態,調整控制其優
執行緒管理(七)守護執行緒的建立和執行
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:方騰飛 守護執行緒的建立和執行 Java有一種特別的執行緒叫做守護執行緒。這種執行緒的優先順序非常低,通常在程式裡沒有其他執行緒
執行緒管理(五)執行緒的睡眠和恢復
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:歐振聰 執行緒的睡眠與恢復 有時, 你會感興趣在一段確定的時間內中斷執行執行緒。例如, 程式的一個執行緒每分鐘檢查反應器狀態。其
執行緒管理(六)等待執行緒的終結
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:方騰飛 等待執行緒的終結 在某些情況下,我們需要等待執行緒的終結。例如,我們可能會遇到程式在執行前需要初始化資源。在執行剩下的程
第一章-執行緒管理(引言)
宣告:本文是《 Java 7 Concurrency Cookbook 》的第一章, 作者: Javier Fernández González 譯者:鄭玉婷 校對:歐振聰 1 執行緒管理 章節提要: 介紹 在計算機世界,當人們談到併發時,它的意思是一系列的任務在計算機中同時執行。如果計算
第四章 執行緒執行者(一)引言
宣告:本文是《 Java 7 Concurrency Cookbook 》的第四章,作者: Javier Fernández González 譯者:許巧輝 校對:方騰飛 在這個章節中,我們將覆蓋: 執行多個任務並處理所有結果 執行者延遲執行一個任務 執行者週期性地執