2. 程式人生 > >Android多執行緒-AsyncTask的使用和問題(取消，並行和序列，螢幕切換)

Android多執行緒-AsyncTask的使用和問題(取消，並行和序列，螢幕切換)

阿新 • • 發佈：2019-01-07

AsyncTask是Android提供的一個執行非同步工作的類，內部其實是運用了執行緒池和Handler來進行非同步任務的執行和與主執行緒的互動。AsyncTask只是一個輔助類，適合執行時間短的非同步任務。

本文基於Android7.0的程式碼來說的。

示例

AsyncTask的使用方法是很簡單的。就做一個簡單的進度條。

佈局是這樣的：

這裡寫圖片描述

裡面有一個進度條ProgressBar pb1,開始按鈕Button btn1，停止按鈕Button stop1

然後實現一個AsyncTask，通過構造方法接收一個ProgressBar和Button進行操作：

public class
 
 MyAsyncTask extends AsyncTask<String, Integer, String> {
    private String TAG = this.getClass().getSimpleName();

    Button btn;
    ProgressBar pb;

    public MyAsyncTask(Button btn, ProgressBar pb) {
        this.btn = btn;
        this.pb = pb;
    }

    @Override
    protected String doInBackground
 
(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            publishProgress(i);
        }

        return
 
 result;
    }

    @Override
    protected void onPreExecute() {
        Log.i(TAG, "onPreExecute: 準備工作");
    }

    @Override
    protected void onPostExecute(String s) {
        btn.setText(s);
        Log.i(TAG, "onPostExecute: 回撥");
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        pb.setProgress(values[0]);
    }
}

然後給兩個按鈕新增點選事件：

MyAsyncTask task1
task1 = new MyAsyncTask(btn1, pb1);
btn1.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.i(TAG, "onClick: 開始1");
        task1.execute();
    }
});
stop1.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.i(TAG, "onClick: 停止1");
        task1.cancel(true);
    }
});

這裡寫圖片描述

這裡寫圖片描述

1.構造引數

AsyncTask定義了三個泛型引數，在繼承的時候必須填寫。例如上面的AsyncTask<String, Integer, String>

在原始碼中定義是：

這裡寫圖片描述

引數含義在下面的方法中會具體用到，先大致瞭解一下：

  • Params 啟動任務的時候輸入的引數型別，一般都是String型別，如填個網址啥的。 上面示例中就是String型別。
  • Progress 用來更新進度的型別。表示任務執行的進度的型別。 示例用的進度條，所以選擇Integer型別。
  • Result 後臺任務執行完後返回的結果， 示例中返回的也是String型別。

2.重寫方法

要使用AsyncTask最少需要重寫方法doInBackground。因為只有這個方法是抽象方法。

這裡寫圖片描述

這個方法是在後臺執行緒執行的。可以看到使用的引數型別Params就是在構造時定義的第一個型別。而返回的型別Result就是定義的第三個型別。

初次之外一般為了對任務流程進行控制還會重寫下面幾個方法onPreExecute,onPostExecute,onProgressUpdate。

下面幾個方法在AsyncTask中是空的,而且都要求在主執行緒中執行。

@MainThread
protected void onPreExecute() {
}
@MainThread
protected void onPostExecute(Result result) {
}
@MainThread
protected void onProgressUpdate(Progress... values) {
}
  • onPreExecute() 在非同步任務開始前做的操作，
  • onPostExecute(Result result) 後臺任務執行完後，通過這個方法能拿到任務返回的結果，進行處理。
  • onProgressUpdate(Progress… values) 這個表示進度變化，引數型別是構造時的第二個型別Progress。進度應該是隨著任務的執行實時更新的，但是這個方法要在主執行緒中執行，而doInBackground是在子執行緒中執行，所以不能直接在doInBackground中呼叫onProgressUpdate方法，而是通過呼叫publishProgress(Progress... values)來間接呼叫這個方法。

3.開始任務

AsyncTask的開始有下面三種方法：

execute(Params... params)
executeOnExecutor(Executor exec,Params... params) 
execute(Runnable runnable)

  • execute(Params… params) 這個就是在示例中使用的開始任務的方式，傳入指定的引數，引數型別要和構造時定義的第一個引數型別Params一樣。引數可以為空的，那麼在方法doInBackground(Params... params)中的引數也是空的。使用預設的執行緒池執行任務，會按流程執行onPreExecute,doInBackground(Params... params),onPostExecute(Result result)等方法。

  • executeOnExecutor(Executor exec,Params… params) 如果預設的執行緒池不能滿足你的要求，可以用這個方法用指定執行緒池來執行任務。流程跟上面是一樣的。

  • execute(Runnable runnable) 這個方法傳進來的是一個Runnable型別，方法中只有一行程式碼sDefaultExecutor.execute(runnable)就是用預設的執行緒池直接執行任務，就是使用執行緒池了，跟前面那些重寫的方法沒關係。

    ​

4.停止任務

要停止任務可以呼叫下面的方法：

public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

下面是停止的演示：

這裡寫圖片描述

取消也有一個回撥方法可以重寫,這裡加上，也是執行在主執行緒中：

@Override
protected void onCancelled() {
    Log.i(TAG, "onCancelled: 取消任務");
    btn.setText("取消了");
}

取消的問題

當cancel方法被呼叫後，onPostExecute和onProgressUpdate方法都不會再呼叫了。而doInBackground方法卻會一直執行下去，也就是後臺任務會繼續執行。

cancel(boolean mayInterruptIfRunning)這個引數mayInterruptIfRunning文件中表示是否應該立即終止doInBackground中的任務。

然而實際用起來就不是那樣的了，無論我們傳的是true還是false，而AsyncTask的cancle方法只是打上了一個取消的標記。並不是直接終止任務。如果是true，則會呼叫一下後臺執行緒的interrupt方法。

當呼叫了cancle方法後，呼叫isCancelled方法會返回true。在doInBackground中應該呼叫isCancelled來檢查當前任務是否被取消，以便及時終止任務。

AsyncTask設計成這樣就是為了方便更新主執行緒介面的，所以對使用者來說，在呼叫了cancle方法後，後臺的任務就不會在影響到主執行緒的介面變化了，因為後續的跟主執行緒互動的方法都不會再執行了。，也可以說是取消了。

而真的要及時取消doInBackground的繼續執行則需要在這個方法中進行一些判斷。

不做處理

不做處理也就是在doInBackground中不做判斷，像下面這樣。看一下輸出的日誌。當然介面的進度條都會停住，只要看doInBackground有沒有在點選停止按鈕後停下來。

protected String doInBackground(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            publishProgress(i);
        }
        return result;
    }
  • cancle(true):

這裡寫圖片描述

  • cancle(false):

這裡寫圖片描述

可以看到區別是，當值為true的時候，後臺執行緒也會跑完。但是會呼叫子執行緒的interrupt方法，而這個現在正在sleep，所以會引發InterruptedException.

而值為false的時候，沒有任何變化，後臺執行緒繼續跑完。

做處理

1. 判斷isCancelled

在不同的執行節點判斷這個方法的值：

@Override
protected String doInBackground(String... params) {
    String result = "完成";
    for (int i = 1; i <= 10; i++) {
        try {
            if (isCancelled()){
                Log.i(TAG, "doInBackground: 被標記停止了");
                break;
            }
            Log.i(TAG, "doInBackground: "+i);
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        publishProgress(i);
    }
    return result;
}

這時呼叫cancle(false)：

這裡寫圖片描述

呼叫cancle(true)只是會多列印一個異常，一樣會停止。

2.抓異常

因為呼叫cancle(true)的時候有可能會丟擲異常，如這個例子中的InterruptedException，因此可以通過異常捕捉來實現。

@Override
protected String doInBackground(String... params) {
    String result = "完成";
    for (int i = 1; i <= 10; i++) {
        try {
            Log.i(TAG, "doInBackground: "+i);
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
            Log.i(TAG, "doInBackground: 捕捉到異常,退出");
            break;
        }
        publishProgress(i);
    }
    return result;
}

這時呼叫cancle(true)：

這裡寫圖片描述

並行和序列

據說AsyncTask的任務是並行還是序列執行在不同Android版本有所變化，但是從API13開始，AsyncTask的任務執行都是序列的。

何為序列，比如有下面的介面：

這裡寫圖片描述

有兩個task

private ProgressBar pb1;
private ProgressBar pb2;
private Button btn1;
private Button btn2;
private Button stop1;
private Button stop2;
private MyAsyncTask task1, task2;
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        task1 = new MyAsyncTask(btn1, pb1);
        task2 = new MyAsyncTask(btn2, pb2);java
        btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 開始1");
                task1.execute();
            }
        });
        btn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 開始2");
                task2.execute();
            }
        });
        stop1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 停止1 ");
                task1.cancel(true);
            }
        });
        stop2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 停止2");
                task2.cancel(false);
            }
        });
    }

在上面的MyAstncTask中，後臺任務要執行10秒。

這裡為了區分，列印開始按鈕的名字來區分：

public class MyAsyncTask extends AsyncTask<String, Integer, String> {
    private String TAG = this.getClass().getSimpleName();

    Button btn;
    ProgressBar pb;
    String name;
    public MyAsyncTask(Button btn, ProgressBar pb) {
        this.btn = btn;
        this.pb = pb;
        name = btn.getText().toString();
    }

    @Override
    protected String doInBackground(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+name+" "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
                Log.i(TAG, "doInBackground: 捕捉到異常,退出");
                break;
            }
            publishProgress(i);
        }

        return result;
    }

    @Override
    protected void onPreExecute() {
        Log.i(TAG, "onPreExecute: 準備工作 "+name);
    }

    @Override
    protected void onPostExecute(String s) {
        btn.setText(s);
        Log.i(TAG, "onPostExecute: 回撥 "+name);
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        pb.setProgress(values[0]);
    }


    @Override
    protected void onCancelled() {
        Log.i(TAG, "onCancelled: 取消任務 "+name);
        btn.setText("取消了");
    }
}

在點選第一個開始按鈕之後點選第二個開始按鈕，效果：

這裡寫圖片描述

列印日誌:

這裡寫圖片描述

雖然點選了開始2，但是依然等第一個任務完成了才開始第二個任務。

想要讓任務並行執行怎麼辦呢？其實他之所以會序列執行任務，是因為內部預設的執行緒池中將任務進行了排隊，保證他們一個一個來。只要我們換個滿足要求的執行緒池來執行任務就行了。AstncTask內部就有一個執行緒池AsyncTask.THREAD_POOL_EXECUTOR可以使用。當然，用Executors來建立也行。

然後將開始任務的execute(Params... params)方法改為executeOnExecutor(Executor exec,Params... params).這裡用AsyncTask.THREAD_POOL_EXECUTOR.

task1.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
task2.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);

效果：

這裡寫圖片描述

日誌：

這裡寫圖片描述

螢幕橫豎屏切換

使用AsyncTask的時候，在螢幕切換也會出現問題。

畫面是這樣的：

這裡寫圖片描述

日誌是這樣的，動圖中也能看見：

這裡寫圖片描述

雖然螢幕切換後，任務也在執行，也在不停地呼叫更新進度條的方法，最後也執行了onPostExecute方法，但是介面上就是什麼變化都沒有。

因為在橫豎屏切換的時候，Activity會銷燬重建，所以AsyncTask所持有的引用就不是新建的Activity的控制元件了，新的Activity就不會變化了。

其中一種解決方法

很簡單,加上這句就行了。

這裡寫圖片描述

這時螢幕怎麼切換都沒事

這裡寫圖片描述

相關推薦

Android多執行緒-AsyncTask的使用和問題(取消，並行和序列，螢幕切換)

AsyncTask是Android提供的一個執行非同步工作的類，內部其實是運用了執行緒池和Handler來進行非同步任務的執行和與主執行緒的互動。AsyncTask只是一個輔助類，適合執行時間短的非同步任務。 本文基於Android7.0的程式碼來說的。

理解Android多執行緒裡面三種任務Runnable和Callable和FutureTask的用法

理解三種任務Runnable和Callable和FutureTask的用法 1.Runnable 和Callable和FutureTask的區別 相同點：都屬於執行緒池中要被執行的任務; 不同點： Runnable是無返回值的任務,可以線上程中使用 Callable是有返回

Android 的執行緒(AsyncTask、IntentService詳解)和執行緒池

前言：不變的還是那顆勇往直前的心。          心得來源於：《Android開發藝術探索》 Android 的執行緒和執行緒池 在作業系統中，執行緒是作業系統排程的最小單元，同時執行緒又

Android多執行緒-AsyncTask工作流程(原始碼)

AsyncTask的原始碼是很簡單的，看著並不複雜。只是對Handler和ThreadPoolExecutor進行了一下封裝。 基於api25（7.1）的程式碼， 使用起來也是很簡單的，看上個就知道了。一般要繼承AsyncTask並重寫下面幾個方法,這些方法

Android多執行緒---AsyncTask原始碼分析

Android多執行緒—AsyncTask使用原始碼分析 一、前言 上篇文章對 HandlerThread 的原始碼進行了分析，相信大家對 HandlerThread 有了一定的認識。如果我們需要執行一個非同步任務，並且執行完畢之後在主執行緒中更新

Android 多執行緒-----Handler、Thread、HandlerThread的區別和使用

一、他們的區別       ①Handler：在android中負責傳送和處理訊息，通過它可以實現其他支線執行緒與主執行緒之間的訊息通訊。       ②Thread：Java程序中執行運算的最小單位，亦即執行處理機排程的基本單位

Android多執行緒-----併發和同步（volatile）

volatile是Java提供的一種輕量級的同步機制，在併發程式設計中，它也扮演著比較重要的角色。同synchronized相比（synchronized通常稱為重量級鎖），volatile更輕量級，相比使用synchronized所帶來的龐大開銷，倘若能恰當的合理的使用volatile，自然是好事

Android多執行緒-----併發和同步（Lock）

一、為什麼需要Lock 如果一個程式碼塊被synchronized修飾了，當一個執行緒獲取了對應的鎖，並執行該程式碼塊時，其他執行緒便只能一直等待，等待獲取鎖的執行緒釋放鎖，而這裡獲取鎖的執行緒釋放鎖只會有兩種情況： 1）獲取鎖的執行緒執行完了該程式碼塊，然後執行緒釋放對鎖的佔有； 2）執行緒執

Android多執行緒-----併發和同步（synchronized）

一、鎖 物件的內建鎖和物件的狀態之間是沒有內在的關聯的，雖然大多數類都將內建鎖用做一種有效的加鎖機制，但物件的域並不一定通過內建鎖來保護。當獲取到與物件關聯的內建鎖時，並不能阻止其他執行緒訪問該物件，當某個執行緒獲得物件的鎖之後，只能阻止其他執行緒獲得同一個鎖。之所以每個物件都有一個內建鎖，是為

Android多執行緒-----併發和同步（ThreadLocal）

一.對ThreadLocal的理解        很多地方叫做執行緒本地變數，也有些地方叫做執行緒本地儲存，其實意思差不多。可能很多朋友都知道ThreadLocal為變數在每個執行緒中都建立了一個副本，那麼每個執行緒可以訪問自己內部的副本變數，也就是進行資

[Android] 多執行緒-Handler和Thread的關係

多執行緒的部分，有幾個名詞 Runnable 工作包 (要做的事情) Thread 執行緒 Handler Message ————————————————————————– Runnable 就是像是專案管理裡的工作包，說穿了就是要做的事情啦，像是這樣 private Runnable r1=new

Android多執行緒-----非同步（AsyncTask）

一、總述 在Android當中，提供了非同步訊息處理機制的兩種方式來解決執行緒之間的通訊問題，一種是通過Handler的機制(這種方式在後面的部落格中將詳細介紹),還有一種就是今天要詳細講解的 AsyncTask 機制。 Android中的工作者執行緒主要有AsyncTask、In

Android多執行緒-----併發和同步（原子變數）

在java中的變數在++等操作是不是原子操作，分為先加一，然後賦值，從而在多執行緒編碼時需要加上synchronizeed，為了增加易用性，java當前提供了原子變數，當前的原子變數有AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference等，其特

NSURLSession和多執行緒網路之GCD簡單介紹（任務，佇列）

NSURLConnection是2003年伴隨著Safari一起發行的網路開發API，距今已經有十一年。當然，在這十一年間它表現的相當優秀，有大量的應用基礎，這也是為什麼前面花了那麼長時間對它進行詳細介紹的原因。但是這些年伴隨著iPhone、iPad的發展，對於NSURL

Android---多執行緒：繼承Thread 類和實現Runnable 介面的區別

參考： Java中執行緒的建立有兩種方式： 1、通過繼承Thread類，重寫Thread的run()方法，將執行緒執行的邏輯放在其中。多個執行緒分別完成自己的任務。 2、通過實現Runnable介面，例項化Thread類。多個執行緒共同完成一個任務

Android多執行緒任務優化1：探討AsyncTask的缺陷

導語：在開發Android應用的過程中，我們需要時刻注意保障應用的穩定性和介面響應性，因為不穩定或者響應速度慢的應用將會給使用者帶來非常差的互動體驗。在越來越講究使用者體驗的大環境下，使用者也許會因為應用的一次Force Close(簡稱FC)或者延遲嚴重的動畫效果而解除安

Android多執行緒(二)AsyncTask原始碼分析

AsyncTask的基本用法這裡就不在贅述了，是個安卓開發者就會。 1.android 3.0以前的 AsyncTask private static final int CORE_POOL_SIZE = 5; private static final int MAX

我的android多執行緒程式設計之路（1）之經驗詳解，原始碼分析

寫在伊始 android開發這麼久了，對於多執行緒這塊一直處於似懂非懂的神奇狀態，今天總結出來，分享一下，希望大家多多指正。共同交流，懇望得到您的建議。 本文簡介 本文會基於自己在開發中對於執行緒這塊的實際使用，大概從執行緒程序的概念，執行緒的建立（T

Android多執行緒之AsyncTask

　　對Android開發者來說，如何處理多執行緒問題是無法繞過的問題。每個Android開發者或多或少都遇到過ANR(Applicatin Not Responding)異常，Android預設當UI執行緒阻塞超過20s時將會引發ANR異常。因此在處理耗時操

Android 的執行緒(AsyncTask、HandlerThread、IntentService詳解)和執行緒池

Android 的執行緒和執行緒池 在作業系統中，執行緒是作業系統排程的最小單元，同時執行緒又是一種受限的系統資源，即執行緒不可能無限制的產生，並且執行緒的建立和銷燬都有一定的開銷。 當系統中存在大量的執行緒時，系統會通過時間片輪轉的方式排程每個執行緒，因此