安卓利用Handlers,AsyncTask和Loaders運行後臺程序

時間 2019-11-17

標籤利用 handlers asynctask loaders 運行後臺程序欄目 Android 简体版

原文原文鏈接

安卓的用戶界面線程(user interface thread)java

1.1 主線程android

安卓修改用戶界面並從一個單一用戶界面線程中處理輸入事件，這個線程也被稱做主線程(main thread)程序員

Android將全部的事件都收集進一個隊列中，而且做爲Looper類的一個實例來進行處理數據庫

1.2爲何要利用併發性apache

若是程序不使用任何併發結構，那麼一個安卓app的全部代碼都運行在一個主線程中，並且每一段代碼都要在等待它前面的代碼運行完以後才能運行。緩存

若是有一個持續時間比較長的操做，好比從網絡上加載數據，那麼這個應用就會被卡住，必須一直等到相應的操做完成。網絡

要想有一個好的用戶體驗，全部潛在的，運行較慢的操做都應該構建異步。併發

在安卓中使用java線程結構app

2.1使用java中的Thread和Thread pools異步

安卓支持使用Thread類來實現異步運行，安卓也支持用java.util.concurrent包中的類來實現後臺運行，好比使用ThreadPools和Executor類，若是你想在新的線程中更新用戶界面，你須要與用戶界面線程進行同步。

2.2在Android中使用java Thread類的弊端

若是使用Thread類，就必須在你的代碼中處理如下需求
若是要將結果返回到用戶界面，則須要和主線程同步
默認不會取消線程
沒有默認的線程池
沒有默認的處理配置更改

由於這些限制，安卓開發者通常會使用android特殊的處理方式。

安卓中的併發結構

Android提供了另外的結構來處理異步性，可使用android.os.Handler類或者AsyncTasks類，更加複雜的方法是基於Loader類的留存片斷及服務

Handler

3.1使用Handler類的目的

Handler能夠登記到一個線程中而且提供一個簡單的通道來傳送數據到這個線程中。

一個Handler對象將本身與它建立的線程相關聯。好比說在onCreate()方法中建立Handler類的實例，則此Handler能夠傳送數據到主線程中。

經過Handler的數據能夠是Message的一個實例，或者是Runnable的一個實例

3.2建立並重用Handler實例

要想使用handler必須重寫handleMessage()方法來處理messages線程能夠經過sendMessage(Message)來傳送messages，或者使用sendEmptyMessage()

在Runnable中，可使用post()方法，爲了不建立對象，能夠重用activity中已經存在的Handler對象。

Handler = getWindow().getDecorView().getHandler();

View類容許經過post()方法傳遞Runnable類型的對象。

3.3舉例

如下代碼演示如何經過View來使用Handler

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ProgressBar
        android:id="@+id/progressBar1"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:indeterminate="false"
        android:max="10"
        android:padding="4dip" >
    </ProgressBar>
    
   <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="" >
      </TextView>
    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="startProgress"
        android:text="Start Progress" >
    </Button>

</LinearLayout>

package de.vogella.android.handler;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.TextView;

public class ProgressTestActivity extends Activity {
  private ProgressBar progress;
  private TextView text;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    progress = (ProgressBar) findViewById(R.id.progressBar1);
    text = (TextView) findViewById(R.id.textView1);

  }

  public void startProgress(View view) {
    // do something long
    Runnable runnable = new Runnable() {
      @Override
      public void run() {
        for (int i = 0; i <= 10; i++) {
          final int value = i;
           doFakeWork();
          progress.post(new Runnable() {
            @Override
            public void run() {
              text.setText("Updating");
              progress.setProgress(value);
            }
          });
        }
      }
    };
    new Thread(runnable).start();
  }

  // Simulating something timeconsuming
  private void doFakeWork() {
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

}

AsyncTask

4.1使用AsyncTask類的目的

AsyncTask類將建立後臺運行程序和與主線程同步的全部操做都封裝起來。它還支持通知運行中的程序的進度

4.2使用AsyncTask類

想使用AsyncTask必須繼承它，AsyncTask使用泛型和可變參數。參數以下AsyncTask <TypeOfVarArgParams , ProgressValue , ResultValue>

一個AsyncTask經過execute方法開始

Execute()方法調用doInBackground()和onPostExecute()方法。

TypeOfVarArgParams 傳遞到doInBackground()方法中，ProgressValue做爲進度信息，ResultValue必須從doInBackground()方法中返回並做爲參數傳遞到onPostExecute()方法中。

doInBackground()方法包含在後臺線程中執行的程序，這個方法在一個單獨的線程中自動運行。

onPostExecute()方法與主線程同步，並更新主線程，這個方法在doInBackground()完成後被調用。

4.3多個異步任務的並行執行

在Android中可使用executeOnExecutor()方法來實現並行執行，將AsyncTask.THREAD_POOL_EXECUTOR做爲第一個參數。

// ImageLoader extends AsyncTask
ImageLoader imageLoader = new ImageLoader(imageView);

// Execute in parallel
imageLoader.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "http://url.com/image.png");

4.4AsyncTask的弊端

AsyncTask不會自動處理配置的變化，若是活動被從新建立，程序員必須在代碼中本身處理。解決這種問題的通常方法是在一個保留片斷中聲明AsyncTask

4.5例子

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <Button
        android:id="@+id/readWebpage"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:onClick="onClick"
        android:text="Load Webpage" >
    </Button>

    <TextView
        android:id="@+id/TextView01"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="Placeholder" >
    </TextView>

</LinearLayout>

package de.vogella.android.asynctask;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

import de.vogella.android.asyntask.R;

import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;

public class ReadWebpageAsyncTask extends Activity {
  private TextView textView;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    textView = (TextView) findViewById(R.id.TextView01);
  }

  private class DownloadWebPageTask extends AsyncTask<String, Void, String> {
    @Override
    protected String doInBackground(String... urls) {
      String response = "";
      for (String url : urls) {
        DefaultHttpClient client = new DefaultHttpClient();
        HttpGet httpGet = new HttpGet(url);
        try {
          HttpResponse execute = client.execute(httpGet);
          InputStream content = execute.getEntity().getContent();

          BufferedReader buffer = new BufferedReader(new InputStreamReader(content));
          String s = "";
          while ((s = buffer.readLine()) != null) {
            response += s;
          }

        } catch (Exception e) {
          e.printStackTrace();
        }
      }
      return response;
    }

    @Override
    protected void onPostExecute(String result) {
      textView.setText(result);
    }
  }

  public void onClick(View view) {
    DownloadWebPageTask task = new DownloadWebPageTask();
    task.execute(new String[] { "http://www.vogella.com" });

  }
}

後臺程序運行及生命週期處理

5.1當配置發生改變時恢復狀態

在使用線程的時候，面臨的一個挑戰，就是須要考慮到應用的生命週期。安卓系統會殺死activity或者產生一個能夠觸發activity重啓的配置變化。

同時，你還要處理已經打開的對話框，由於對話框也與activity相關聯，當activity重啓的時候，訪問現有的對話框時，會獲得一個View not attached to window manager 的異常

可使用onRetainNonConfigurationInstance()方法來保存對象，經過getLastNonConfigurationInstance()方法來取回以前保存的對象。若是活動是第一次啓動，或者經過finish()方法結束，則getLastNonConfigurationInstance()方法返回null，可是onRetainNonConfigurationInstance()在API13以後就被廢除了，建議使用fragment和setRetainInstace()方法來保存數據。

5.2使用appliccation來存儲對象

若是當配置發生變化時，多於一個對象要被存儲在活動中，則能夠經過繼承Application類來實現，須要在AndroidManifest.xml中配置，將繼承了Application類的類名分配給android:name屬性。

<application android:icon="@drawable/icon" android:label="@string/app_name"
  android:name="MyApplicationClass">
   <activity android:name=".ThreadsLifecycleActivity"
    android:label="@string/app_name">
     <intent-filter>
      <action android:name="android.intent.action.MAIN" />
      <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
  </activity>
</application>

應用類將會被Android runtime自動建立，而且一直可用，除非整個應用進程終止。

這個類能夠用來獲取那些能夠在活動之間傳遞或者在整個應用週期中均可用的數據，在onCreate（）方法裏，你能夠建立對象而且將他們設爲public或者建立getter方法以便獲取他們。

onTerminate()方法只是被用來測試。若是Android終止進程，則全部的相關資源都會被釋放。

能夠經過getApplication()來獲得Application類

Loader

6.1 使用Loader的目的

Loader類能夠容許你在活動或者碎片中異步加載數據，他們能夠監控數據源而且當內容發送變化時，將最新的結果傳遞出來。可以保持數據，即便環境發送變化。

若是結果被Loader恢復，當對象和它的父(活動或者碎片)已經失去聯繫的時候，Loader能夠緩存數據。

6.2 實現一個Loader

可使用一抽象類AsyncTaskLoader做爲你本身的Loader的基礎，並實現它

LoaderManager管理一個或多個Loader實例，能夠如下面的方法來建立一個Loader

# start a new loader or re-connect to existing one
getLoaderManager().initLoader(0, null, this);

第一個參數是一個惟一的id，用於在回調時辨別是哪一個Loader。第二個參數是一個bundle，用於攜帶信息，第三個參數回調類，必須繼承LoaderManger.LoaderCallbacks接口、

Loader不是直接經過調用getLoaderManager().initLoader()方法建立的，而是必須在回調方法onCreateLoader()中建立。一旦Loader完成了讀取數據的工做，就會觸發onLoadFinished()方法，在這裏方法裏能夠更新用戶界面

6.3 SQLite數據庫和CursorLoader

Android提供了一個Loader，這個Loader默認實現瞭如何和SQlite數據庫相關聯的操做，即

CursorLoader類

若是Cursor沒法使用時，onLoaderReset()方法就會被觸發。

Custom Loader for preference

下面的代碼將建立一個自定義的loader，並實現管理偏好。

package com.vogella.android.loader.preferences;

import android.content.AsyncTaskLoader;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;

public class SharedPreferencesLoader extends AsyncTaskLoader<SharedPreferences>
    implements SharedPreferences.OnSharedPreferenceChangeListener {
  private SharedPreferences prefs = null;

  public static void persist(final SharedPreferences.Editor editor) {
    editor.apply();
  }

  public SharedPreferencesLoader(Context context) {
    super(context);
  }

  // Load the data asynchronously
  @Override
  public SharedPreferences loadInBackground() {
    prefs = PreferenceManager.getDefaultSharedPreferences(getContext());
    prefs.registerOnSharedPreferenceChangeListener(this);
    return (prefs);
  }

  @Override
  public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
      String key) {
    // notify loader that content has changed
    onContentChanged();
  }

  
/**
   * starts the loading of the data 
   * once result is ready the onLoadFinished method is called
   * in the main thread. It loader was started earlier the result
   * is return directly

   * method must be called from main thread.
   */

  @Override
  protected void onStartLoading() {
    if (prefs != null) {
      deliverResult(prefs);
    }

    if (takeContentChanged() || prefs == null) {
      forceLoad();
    }
  }
}

在活動中使用此loader

package com.vogella.android.loader.preferences;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.LoaderManager;
import android.content.Loader;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends Activity implements
    LoaderManager.LoaderCallbacks<SharedPreferences> {
  private static final String KEY = "prefs";
  private TextView textView;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    textView = (TextView) findViewById(R.id.prefs);
    getLoaderManager().initLoader(0, null, this);

  }

  @Override
  public Loader<SharedPreferences> onCreateLoader(int id, Bundle args) {
    return (new SharedPreferencesLoader(this));
  }

  @SuppressLint("CommitPrefEdits")
  @Override
  public void onLoadFinished(Loader<SharedPreferences> loader,
      SharedPreferences prefs) {
    int value = prefs.getInt(KEY, 0);
    value += 1;
    textView.setText(String.valueOf(value));
    // update value
    SharedPreferences.Editor editor = prefs.edit();
    editor.putInt(KEY, value);
    SharedPreferencesLoader.persist(editor);
  }

  @Override
  public void onLoaderReset(Loader<SharedPreferences> loader) {
    // NOT used
  }
}

利用service運行後臺任務

下面的代碼將實現下載圖片，而且展現有個dialog，直到下載完成，這個dialog纔會消失。要確保即便活動重啓線程也被保留下來。

public class ThreadsLifecycleActivity extends Activity {  // Static so that the thread access the latest attribute
  private static ProgressDialog dialog;  
  private static Bitmap downloadBitmap;
  private static Handler handler;
  private ImageView imageView;
  private Thread downloadThread;
 /** Called when the activity is first created. */

  @Override
  public void onCreate(Bundle savedInstanceState) {    
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);    // create a handler to update the UI
    handler = new Handler() {      @Override
      public void handleMessage(Message msg) {
        imageView.setImageBitmap(downloadBitmap);
        dialog.dismiss();
      }

    };    
    // get the latest imageView after restart of the application
    imageView = (ImageView) findViewById(R.id.imageView1);
    Context context = imageView.getContext();
    System.out.println(context);
    // Did we already download the image?
    if (downloadBitmap != null) {
      imageView.setImageBitmap(downloadBitmap);
    }
        // check if the thread is already running
    downloadThread = (Thread) getLastNonConfigurationInstance();
  if (downloadThread != null && downloadThread.isAlive()) {
      dialog = ProgressDialog.show(this, "Download", "downloading");
    }
  }  public void resetPicture(View view) {    if (downloadBitmap != null) {
      downloadBitmap = null;
    }
    imageView.setImageResource(R.drawable.icon);
  }  public void downloadPicture(View view) {
    dialog = ProgressDialog.show(this, "Download", "downloading");
    downloadThread = new MyThread();
    downloadThread.start();
  }  // save the thread
  @Override
  public Object onRetainNonConfigurationInstance() {
      return downloadThread;
  }  // dismiss dialog if activity is destroyed
  @Override
  protected void onDestroy() {
   if (dialog != null && dialog.isShowing()) {
      dialog.dismiss();
      dialog = null;
    }    
   super.onDestroy();
  }  // Utiliy method to download image from the internet
  static private Bitmap downloadBitmap(String url) throws IOException {
    HttpUriRequest request = new HttpGet(url);
    HttpClient httpClient = new DefaultHttpClient();
    HttpResponse response = httpClient.execute(request);

    StatusLine statusLine = response.getStatusLine();    
    int statusCode = statusLine.getStatusCode();
    if (statusCode == 200) {
      HttpEntity entity = response.getEntity();
      byte[] bytes = EntityUtils.toByteArray(entity);

      Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0,
          bytes.length);
      return bitmap;
    } else {
      throw new IOException("Download failed, HTTP response code "
          + statusCode + " - " + statusLine.getReasonPhrase());
    }
  }  
    static public class MyThread extends Thread {
        @Override
    public void run() {
    try {   // Simulate a slow network
        try {
            new Thread().sleep(5000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        downloadBitmap = downloadBitmap("http://www.devoxx.com/download/attachments/4751369/DV11");
        // Updates the user interface
        handler.sendEmptyMessage(0);
      } catch (IOException e) {
        e.printStackTrace();
      } finally {

      }
    }
  }

}