AsyncTask

AsyncTask和Handler對比

AsyncTask實現的原理,和適用的優缺點

AsyncTask,是android提供的輕量級的非同步類,可以直接繼承AsyncTask,在類中實現非同步操作,並提供介面反饋當前非同步執行的程度(可以通過介面實現UI進度更新),最後反饋執行的結果給UI主執行緒.

使用的優點:

簡單,快捷

過程可控

使用的缺點:

在使用多個非同步操作和並需要進行Ui變更時,就變得複雜起來

Handler非同步實現的原理和適用的優缺點

在Handler 非同步實現時,涉及到 Handler, Looper, Message,Thread四個物件，實現非同步的流程是主執行緒啟動Thread（子執行緒）àthread(子執行緒)執行並生成Message-àLooper獲取Message並傳遞給HandleràHandler逐個獲取Looper中的Message，並進行UI變更。

使用的優點：

l結構清晰，功能定義明確

對於多個後臺任務時，簡單，清晰

使用的缺點：

在單個後臺非同步處理時，顯得程式碼過多，結構過於複雜（相對性）

AsyncTask實現單個進度條

首先我們得要一個佈局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
 

    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.asus.mytest2.ProgressActivity">

    <SeekBar
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:id="@+id/sk"
 

        android:max="100"/>

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="開始下載1"
        android:id="@+id/btn1_progress"/>



</LinearLayout>

詳細的步驟我寫在程式碼中了：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    initView();

    start.setOnClickListener(this);
    end.setOnClickListener(this);
}

/**
 * Params 啟動任務執行的輸入引數，比如HTTP請求的URL。它是可變型引數。 Progress 後臺任務執行的百分比 Result
 * 後臺執行任務最終返回的結果，比如String。 如果某個泛型引數不需要指定型別時，可將它的設定為了Void
 * 
 * @author TED
 *
 */
class MyTask extends AsyncTask<String, Integer, String> {

    /**
     * 該方法將在執行實際的後臺操作前被UI 執行緒呼叫。
     * 可以在該方法中做一些準備工作，如在介面上顯示一個進度條，或者一些控制元件的例項化，這個方法可以中實現。
     */
    @Override
    protected void onPreExecute() {
        tv.setText("下載中。。。");
        super.onPreExecute();
    }

    /**
     * 該方法執行在後臺執行緒中。這裡將主要負責執行那些很耗時的後臺處理工作 可以呼叫 publishProgress方法來更新實時的任務進度
     */
    @Override
    protected String doInBackground(String... params) {
        for(int i = 0; i<100; i++){
            try {
                Thread.sleep(500L);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            publishProgress(i);
        }
        return null;
    }

    /**
     * 在doInBackground 執行完成後，onPostExecute 方法將被UI 執行緒呼叫，後臺的計算結果將通過該方法傳遞到UI
     * 執行緒， 並且在介面上展示給使用者.
     * 
     */
    @Override
    protected void onPostExecute(String result) {
        tv.setText("下載完成");
        super.onPostExecute(result);
    }

    /**
     * 在publishProgress方法被呼叫後，UI 執行緒將呼叫這個方法從而在介面上展示任務的進展情況，例如通過一個進度條進行展示。
     */
    @Override
    protected void onProgressUpdate(Integer... values) {
        progressBar.setProgress(values[0]);
        tv.setText("下載中"+values[0]+"%");
        super.onProgressUpdate(values);
    }


    /**
     * 在使用者取消執行緒操作的時候呼叫。在主執行緒中呼叫onCancelled()的時候呼叫。
     */
    @Override
    protected void onCancelled() {
        tv.setText("下載失敗");
        super.onCancelled();
    }

}

@Override
public void onClick(View v) {
    switch (v.getId()) {
    case R.id.start:

        myTask.execute("下載中");
        break;
    case R.id.end:
        myTask.cancel(true);
        break;
    default:
        break;
    }

}

AsyncTask實現進度條主要還是在於要理解每一個方法需要幹什麼，那麼AsyncTask是否能實現兩根進度條互相不干擾的進行讀條呢，答案當然是肯定的

AsyncTask實現兩個進度條

先來一個佈局：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.asus.mytest2.ProgressActivity">

    <SeekBar
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:id="@+id/sk"
        android:max="100"/>

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="開始下載1"
        android:id="@+id/btn1_progress"/>

    <SeekBar
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:id="@+id/sk2"
        android:max="100"/>

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="開始下載2"
        android:id="@+id/btn2_progress"/>

</LinearLayout>

在這裡，要實現多個執行緒，就要好好考慮方法體中可變長度的引數，居然是可變長度，那麼自然可以傳入多個引數，因此就能實現同時進行其它執行緒的操作

package com.example.asus.mytest2;

import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.SeekBar;

public class ProgressActivity extends AppCompatActivity {

    private SeekBar progressBar1,progressBar2;
    private Button btn1, btn2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_progress);

        progressBar1 = (SeekBar) findViewById(R.id.sk);
        progressBar2 = (SeekBar) findViewById(R.id.sk2);
        btn1 = (Button) findViewById(R.id.btn1_progress);
        btn2 = (Button) findViewById(R.id.btn2_progress);

        btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                btn1.setText("下載中。。。");
                btn1.setEnabled(false);
                new MyTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,1);
            }
        });

        btn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                btn2.setText("下載中。。。");
                btn2.setEnabled(false);
                new MyTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,2);
            }
        });

    }

    class MyTask extends AsyncTask<Integer, Integer, Integer> {


        @Override
        protected Integer doInBackground(Integer... values) {
            for (int i = 0; i <= 100; i+=5) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                publishProgress(i,values[0]);
            }
            return values[0];
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            switch (values[1]){
                case 1:
                    progressBar1.setProgress(values[0]);
                    btn1.setText("下載中" + values[0] + "%");
                    break;
                case 2:
                    progressBar2.setProgress(values[0]);
                    btn2.setText("下載中" + values[0] + "%");
                    break;
                default:
                    break;
            }
            super.onProgressUpdate(values);
        }

        @Override
        protected void onPostExecute(Integer result) {
            switch (result){
                case 1:
                    btn1.setText("下載完成");
                    btn1.setEnabled(true);
                    break;
                case 2:
                    btn2.setText("下載完成");
                    btn2.setEnabled(true);
                    break;
                default:
                    break;
            }
            super.onPostExecute(result);
        }
    }
}

這裡我們在publishProgress(i,values[0]);傳入了兩個引數，通過onProgressUpdate方法來判斷需要進行的操作，在這裡，如要要讓程式知道那個是控制那個，我們則需要引入executeOnExecutor()方法，通過內部類來呼叫，這樣就可以完成實現多個執行緒的實現且互不干擾