閱讀832 返回首頁    go 阿裏雲 go 技術社區[雲棲]

Android多線程任務優化：實現後台預讀線程

轉載請注明出處。博客地址：https://blog.csdn.net/mylzc
導語：從上一篇《多線程任務的優化1：探討AsyncTask的缺陷》我們了解到，使用AsyncTask有導致應用FC的風險，而且AsyncTask並不能滿足我們一些特定的需求。下麵我們介紹一種通過模仿AsyncTask的封裝方式，實現一個後台預讀數據的線程。

概述：在空閑時對獲取成本較高的數據（如要讀取本地或網絡資源）進行預讀是提高性能的有效手段。為了給用戶帶來更好的交互體驗，提高響應性，很多網絡應用（如新聞閱讀類應用）都在啟動的時候進行預讀，把網絡數據緩存到sdcard或者內存中。

例子：下麵介紹一個實現預讀的例子，打開應用之後會有一個歡迎界麵，在打開歡迎界麵的同時我們在後台啟動預讀線程，預讀下一個Activity需要顯示的數據,預讀數據保存到一個靜態的Hashmap中。

首先要編寫我們的後台預讀線程，遵循不重複造輪子的原則，我們對AsyncTask稍作修改就可以滿足需求。下麵是我們自定義的PreReadTask類代碼：

PreReadTask.java 實現預讀線程

  1. package com.zhuozhuo;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. import java.util.concurrent.PriorityBlockingQueue;  
  5. import java.util.concurrent.RejectedExecutionHandler;  
  6. import java.util.concurrent.SynchronousQueue;  
  7. import java.util.concurrent.ThreadPoolExecutor;  
  8. import java.util.concurrent.TimeUnit;  
  9. import java.util.concurrent.BlockingQueue;  
  10. import java.util.concurrent.LinkedBlockingQueue;  
  11. import java.util.concurrent.ThreadFactory;  
  12. import java.util.concurrent.Callable;  
  13. import java.util.concurrent.FutureTask;  
  14. import java.util.concurrent.ExecutionException;  
  15. import java.util.concurrent.TimeoutException;  
  16. import java.util.concurrent.CancellationException;  
  17. import java.util.concurrent.atomic.AtomicInteger;  
  18.   
  19. import android.content.SyncResult;  
  20. import android.os.Process;  
  21. import android.os.Handler;  
  22. import android.os.Message;  
  23. public abstract class PreReadTask<Params, Progress, Result> {  
  24.     private static final String LOG_TAG = "FifoAsyncTask";  
  25.   
  26. //    private static final int CORE_POOL_SIZE = 5;  
  27. //    private static final int MAXIMUM_POOL_SIZE = 5;  
  28. //    private static final int KEEP_ALIVE = 1;  
  29.   
  30. //    private static final BlockingQueue<Runnable> sWorkQueue =  
  31. //            new LinkedBlockingQueue<Runnable>();  
  32. //  
  33.     private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
  34.         private final AtomicInteger mCount = new AtomicInteger(1);  
  35.   
  36.         public Thread newThread(Runnable r) {  
  37.             return new Thread(r, "PreReadTask #" + mCount.getAndIncrement());  
  38.         }  
  39.     };  
  40.   
  41.     private static final ExecutorService sExecutor = Executors.newSingleThreadExecutor(sThreadFactory);//隻有一個工作線程的線程池  
  42.   
  43.     private static final int MESSAGE_POST_RESULT = 0x1;  
  44.     private static final int MESSAGE_POST_PROGRESS = 0x2;  
  45.     private static final int MESSAGE_POST_CANCEL = 0x3;  
  46.   
  47.     private static final InternalHandler sHandler = new InternalHandler();  
  48.   
  49.     private final WorkerRunnable<Params, Result> mWorker;  
  50.     private final FutureTask<Result> mFuture;  
  51.   
  52.     private volatile Status mStatus = Status.PENDING;  
  53.   
  54.     /** 
  55.      * Indicates the current status of the task. Each status will be set only once 
  56.      * during the lifetime of a task. 
  57.      */  
  58.     public enum Status {  
  59.         /** 
  60.          * Indicates that the task has not been executed yet. 
  61.          */  
  62.         PENDING,  
  63.         /** 
  64.          * Indicates that the task is running. 
  65.          */  
  66.         RUNNING,  
  67.         /** 
  68.          * Indicates that {@link FifoAsyncTask#onPostExecute} has finished. 
  69.          */  
  70.         FINISHED,  
  71.     }  
  72.   
  73.     /** 
  74.      * Creates a new asynchronous task. This constructor must be invoked on the UI thread. 
  75.      */  
  76.     public PreReadTask() {  
  77.         mWorker = new WorkerRunnable<Params, Result>() {  
  78.             public Result call() throws Exception {  
  79.                 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
  80.                 return doInBackground(mParams);  
  81.             }  
  82.         };  
  83.   
  84.         mFuture = new FutureTask<Result>(mWorker) {  
  85.             @Override  
  86.             protected void done() {  
  87.                 Message message;  
  88.                 Result result = null;  
  89.   
  90.                 try {  
  91.                     result = get();  
  92.                 } catch (InterruptedException e) {  
  93.                     android.util.Log.w(LOG_TAG, e);  
  94.                 } catch (ExecutionException e) {  
  95.                     throw new RuntimeException("An error occured while executing doInBackground()",  
  96.                             e.getCause());  
  97.                 } catch (CancellationException e) {  
  98.                     message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,  
  99.                             new PreReadTaskResult<Result>(PreReadTask.this, (Result[]) null));  
  100.                     message.sendToTarget();  
  101.                     return;  
  102.                 } catch (Throwable t) {  
  103.                     throw new RuntimeException("An error occured while executing "  
  104.                             + "doInBackground()", t);  
  105.                 }  
  106.   
  107.                 message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
  108.                         new PreReadTaskResult<Result>(PreReadTask.this, result));  
  109.                 message.sendToTarget();  
  110.             }  
  111.         };  
  112.     }  
  113.   
  114.     /** 
  115.      * Returns the current status of this task. 
  116.      * 
  117.      * @return The current status. 
  118.      */  
  119.     public final Status getStatus() {  
  120.         return mStatus;  
  121.     }  
  122.   
  123.     /** 
  124.      * Override this method to perform a computation on a background thread. The 
  125.      * specified parameters are the parameters passed to {@link #execute} 
  126.      * by the caller of this task. 
  127.      * 
  128.      * This method can call {@link #publishProgress} to publish updates 
  129.      * on the UI thread. 
  130.      * 
  131.      * @param params The parameters of the task. 
  132.      * 
  133.      * @return A result, defined by the subclass of this task. 
  134.      * 
  135.      * @see #onPreExecute() 
  136.      * @see #onPostExecute 
  137.      * @see #publishProgress 
  138.      */  
  139.     protected abstract Result doInBackground(Params... params);  
  140.   
  141.     /** 
  142.      * Runs on the UI thread before {@link #doInBackground}. 
  143.      * 
  144.      * @see #onPostExecute 
  145.      * @see #doInBackground 
  146.      */  
  147.     protected void onPreExecute() {  
  148.     }  
  149.   
  150.     /** 
  151.      * Runs on the UI thread after {@link #doInBackground}. The 
  152.      * specified result is the value returned by {@link #doInBackground} 
  153.      * or null if the task was cancelled or an exception occured. 
  154.      * 
  155.      * @param result The result of the operation computed by {@link #doInBackground}. 
  156.      * 
  157.      * @see #onPreExecute 
  158.      * @see #doInBackground 
  159.      */  
  160.     @SuppressWarnings({"UnusedDeclaration"})  
  161.     protected void onPostExecute(Result result) {  
  162.     }  
  163.   
  164.     /** 
  165.      * Runs on the UI thread after {@link #publishProgress} is invoked. 
  166.      * The specified values are the values passed to {@link #publishProgress}. 
  167.      * 
  168.      * @param values The values indicating progress. 
  169.      * 
  170.      * @see #publishProgress 
  171.      * @see #doInBackground 
  172.      */  
  173.     @SuppressWarnings({"UnusedDeclaration"})  
  174.     protected void onProgressUpdate(Progress... values) {  
  175.     }  
  176.   
  177.     /** 
  178.      * Runs on the UI thread after {@link #cancel(boolean)} is invoked. 
  179.      * 
  180.      * @see #cancel(boolean) 
  181.      * @see #isCancelled() 
  182.      */  
  183.     protected void onCancelled() {  
  184.     }  
  185.   
  186.     /** 
  187.      * Returns <tt>true</tt> if this task was cancelled before it completed 
  188.      * normally. 
  189.      * 
  190.      * @return <tt>true</tt> if task was cancelled before it completed 
  191.      * 
  192.      * @see #cancel(boolean) 
  193.      */  
  194.     public final boolean isCancelled() {  
  195.         return mFuture.isCancelled();  
  196.     }  
  197.   
  198.     /** 
  199.      * Attempts to cancel execution of this task.  This attempt will 
  200.      * fail if the task has already completed, already been cancelled, 
  201.      * or could not be cancelled for some other reason. If successful, 
  202.      * and this task has not started when <tt>cancel</tt> is called, 
  203.      * this task should never run.  If the task has already started, 
  204.      * then the <tt>mayInterruptIfRunning</tt> parameter determines 
  205.      * whether the thread executing this task should be interrupted in 
  206.      * an attempt to stop the task. 
  207.      * 
  208.      * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this 
  209.      *        task should be interrupted; otherwise, in-progress tasks are allowed 
  210.      *        to complete. 
  211.      * 
  212.      * @return <tt>false</tt> if the task could not be cancelled, 
  213.      *         typically because it has already completed normally; 
  214.      *         <tt>true</tt> otherwise 
  215.      * 
  216.      * @see #isCancelled() 
  217.      * @see #onCancelled() 
  218.      */  
  219.     public final boolean cancel(boolean mayInterruptIfRunning) {  
  220.         return mFuture.cancel(mayInterruptIfRunning);  
  221.     }  
  222.   
  223.     /** 
  224.      * Waits if necessary for the computation to complete, and then 
  225.      * retrieves its result. 
  226.      * 
  227.      * @return The computed result. 
  228.      * 
  229.      * @throws CancellationException If the computation was cancelled. 
  230.      * @throws ExecutionException If the computation threw an exception. 
  231.      * @throws InterruptedException If the current thread was interrupted 
  232.      *         while waiting. 
  233.      */  
  234.     public final Result get() throws InterruptedException, ExecutionException {  
  235.         return mFuture.get();  
  236.     }  
  237.   
  238.     /** 
  239.      * Waits if necessary for at most the given time for the computation 
  240.      * to complete, and then retrieves its result. 
  241.      * 
  242.      * @param timeout Time to wait before cancelling the operation. 
  243.      * @param unit The time unit for the timeout. 
  244.      * 
  245.      * @return The computed result. 
  246.      * 
  247.      * @throws CancellationException If the computation was cancelled. 
  248.      * @throws ExecutionException If the computation threw an exception. 
  249.      * @throws InterruptedException If the current thread was interrupted 
  250.      *         while waiting. 
  251.      * @throws TimeoutException If the wait timed out. 
  252.      */  
  253.     public final Result get(long timeout, TimeUnit unit) throws InterruptedException,  
  254.             ExecutionException, TimeoutException {  
  255.         return mFuture.get(timeout, unit);  
  256.     }  
  257.   
  258.     /** 
  259.      * Executes the task with the specified parameters. The task returns 
  260.      * itself (this) so that the caller can keep a reference to it. 
  261.      * 
  262.      * This method must be invoked on the UI thread. 
  263.      * 
  264.      * @param params The parameters of the task. 
  265.      * 
  266.      * @return This instance of AsyncTask. 
  267.      * 
  268.      * @throws IllegalStateException If {@link #getStatus()} returns either 
  269.      *         {@link FifoAsyncTask.Status#RUNNING} or {@link FifoAsyncTask.Status#FINISHED}. 
  270.      */  
  271.     public final PreReadTask<Params, Progress, Result> execute(Params... params) {  
  272.         if (mStatus != Status.PENDING) {  
  273.             switch (mStatus) {  
  274.                 case RUNNING:  
  275.                     throw new IllegalStateException("Cannot execute task:"  
  276.                             + " the task is already running.");  
  277.                 case FINISHED:  
  278.                     throw new IllegalStateException("Cannot execute task:"  
  279.                             + " the task has already been executed "  
  280.                             + "(a task can be executed only once)");  
  281.             }  
  282.         }  
  283.   
  284.         mStatus = Status.RUNNING;  
  285.   
  286.         onPreExecute();  
  287.   
  288.         mWorker.mParams = params;  
  289.         sExecutor.execute(mFuture);  
  290.   
  291.         return this;  
  292.     }  
  293.   
  294.     /** 
  295.      * This method can be invoked from {@link #doInBackground} to 
  296.      * publish updates on the UI thread while the background computation is 
  297.      * still running. Each call to this method will trigger the execution of 
  298.      * {@link #onProgressUpdate} on the UI thread. 
  299.      * 
  300.      * @param values The progress values to update the UI with. 
  301.      * 
  302.      * @see #onProgressUpdate 
  303.      * @see #doInBackground 
  304.      */  
  305.     protected final void publishProgress(Progress... values) {  
  306.         sHandler.obtainMessage(MESSAGE_POST_PROGRESS,  
  307.                 new PreReadTaskResult<Progress>(this, values)).sendToTarget();  
  308.     }  
  309.   
  310.     private void finish(Result result) {  
  311.         if (isCancelled()) result = null;  
  312.         onPostExecute(result);  
  313.         mStatus = Status.FINISHED;  
  314.     }  
  315.   
  316.     private static class InternalHandler extends Handler {  
  317.         @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})  
  318.         @Override  
  319.         public void handleMessage(Message msg) {  
  320.             PreReadTaskResult result = (PreReadTaskResult) msg.obj;  
  321.             switch (msg.what) {  
  322.                 case MESSAGE_POST_RESULT:  
  323.                     // There is only one result  
  324.                     result.mTask.finish(result.mData[0]);  
  325.                     break;  
  326.                 case MESSAGE_POST_PROGRESS:  
  327.                     result.mTask.onProgressUpdate(result.mData);  
  328.                     break;  
  329.                 case MESSAGE_POST_CANCEL:  
  330.                     result.mTask.onCancelled();  
  331.                     break;  
  332.             }  
  333.         }  
  334.     }  
  335.   
  336.     private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {  
  337.         Params[] mParams;  
  338.     }  
  339.   
  340.     @SuppressWarnings({"RawUseOfParameterizedType"})  
  341.     private static class PreReadTaskResult<Data> {  
  342.         final PreReadTask mTask;  
  343.         final Data[] mData;  
  344.   
  345.         PreReadTaskResult(PreReadTask task, Data... data) {  
  346.             mTask = task;  
  347.             mData = data;  
  348.         }  
  349.     }  
  350. }  


對比AsyncTask我們實際隻修改了一個地方

  1. private static final ExecutorService sExecutor = Executors.newSingleThreadExecutor(sThreadFactory);//隻有一個工作線程的線程池  

通過Executors.newSingleThreadExecutor，我們把PreReadTask的的線程池設置成隻有一個工作線程，並且帶有一個無邊界的緩衝隊列，這一個工作線程以先進先出的順序不斷從緩衝隊列中取出並執行任務。

創建完後台預讀的線程。我們通過一個例子介紹如何使用這個後台預讀線程。

這個例子由兩個Activity組成，WelcomeActivity是歡迎界麵，在歡迎界麵中會停留三秒，在此時我們對數據進行預讀,預讀成功後保存到一個全局的靜態hashmap中。MainActivity是主界麵，在主界麵中顯示一個listview，listview中的圖片是模擬從網絡獲取的，當靜態hashmap中存在數據（也就是已經成功預讀的數據）的時，從hashmap中取，如果不存在，才從網絡獲取。

點此下載工程代碼

WelcomeActivity.java 歡迎界麵，停留三秒，預讀數據

  1. package com.zhuozhuo;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.Intent;  
  5. import android.graphics.BitmapFactory;  
  6. import android.os.AsyncTask;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.widget.Toast;  
  10.   
  11. public class WelcomeActivity extends Activity {  
  12.       
  13.     private Handler handler = new Handler();  
  14.       
  15.     @Override  
  16.     public void onCreate(Bundle savedInstanceState) {  
  17.         super.onCreate(savedInstanceState);  
  18.         setContentView(R.layout.welcome);  
  19.         for(int i = 0; i < 15; i++) {//預讀15張圖片  
  20.             ReadImgTask task = new ReadImgTask();  
  21.             task.execute(String.valueOf(i));  
  22.         }  
  23.         Toast.makeText(getApplicationContext(), "PreReading...", Toast.LENGTH_LONG).show();  
  24.         handler.postDelayed(new Runnable() {  
  25.               
  26.             @Override  
  27.             public void run() {  
  28.                 startActivity(new Intent(WelcomeActivity.this, MainActivity.class));//啟動MainActivity  
  29.                   
  30.                 finish();  
  31.             }  
  32.         }, 3000);//顯示三秒鍾的歡迎界麵  
  33.     }  
  34.       
  35.     class ReadImgTask extends PreReadTask<String, Void, Void> {  
  36.   
  37.         @Override  
  38.         protected Void doInBackground(String... arg0) {  
  39.             try {  
  40.                 Thread.sleep(200);//模擬網絡延時  
  41.             } catch (InterruptedException e) {  
  42.                 // TODO Auto-generated catch block  
  43.                 e.printStackTrace();  
  44.             }  
  45.             Data.putData(arg0[0], BitmapFactory.decodeResource(getResources(), R.drawable.icon));//把預讀的數據放到hashmap中  
  46.             return null;  
  47.         }  
  48.           
  49.     }  
  50.       
  51. }  


MainActivity.java 主界麵，有一個listview，listview中顯示圖片和文字，模擬圖片從網絡異步獲取

  1. package com.zhuozhuo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collection;  
  5. import java.util.HashMap;  
  6. import java.util.Iterator;  
  7. import java.util.List;  
  8. import java.util.ListIterator;  
  9. import java.util.Map;  
  10.   
  11.   
  12. import android.app.Activity;  
  13. import android.app.AlertDialog;  
  14. import android.app.Dialog;  
  15. import android.app.ListActivity;  
  16. import android.app.ProgressDialog;  
  17. import android.content.Context;  
  18. import android.content.DialogInterface;  
  19. import android.content.Intent;  
  20. import android.database.Cursor;  
  21. import android.graphics.Bitmap;  
  22. import android.graphics.BitmapFactory;  
  23. import android.os.AsyncTask;  
  24. import android.os.Bundle;  
  25. import android.provider.ContactsContract;  
  26. import android.util.Log;  
  27. import android.view.LayoutInflater;  
  28. import android.view.View;  
  29. import android.view.ViewGroup;  
  30. import android.widget.AbsListView;  
  31. import android.widget.AbsListView.OnScrollListener;  
  32. import android.widget.Adapter;  
  33. import android.widget.AdapterView;  
  34. import android.widget.AdapterView.OnItemClickListener;  
  35. import android.widget.BaseAdapter;  
  36. import android.widget.GridView;  
  37. import android.widget.ImageView;  
  38. import android.widget.ListAdapter;  
  39. import android.widget.ListView;  
  40. import android.widget.SimpleAdapter;  
  41. import android.widget.TextView;  
  42. import android.widget.Toast;  
  43.   
  44. public class MainActivity extends Activity {  
  45.       
  46.       
  47.     private ListView mListView;  
  48.     private List<HashMap<String, Object>> mData;  
  49.       
  50.     private BaseAdapter mAdapter;  
  51.       
  52.       
  53.     @Override  
  54.     public void onCreate(Bundle savedInstanceState) {  
  55.         super.onCreate(savedInstanceState);  
  56.         setContentView(R.layout.main);  
  57.         mListView = (ListView) findViewById(R.id.listview);  
  58.         mData = new ArrayList<HashMap<String,Object>>();  
  59.         mAdapter = new CustomAdapter();  
  60.           
  61.         mListView.setAdapter(mAdapter);  
  62.         for(int i = 0; i < 100; i++) {//初始化100項數據  
  63.             HashMap data = new HashMap<String, Object>();  
  64.             data.put("title", "title" + i);  
  65.             mData.add(data);  
  66.         }  
  67.     }  
  68.       
  69.       
  70.   
  71.   
  72.     class CustomAdapter extends BaseAdapter {  
  73.   
  74.           
  75.         CustomAdapter() {  
  76.               
  77.         }  
  78.           
  79.         @Override  
  80.         public int getCount() {  
  81.             return mData.size();  
  82.         }  
  83.   
  84.         @Override  
  85.         public Object getItem(int position) {  
  86.             return mData.get(position);  
  87.         }  
  88.   
  89.         @Override  
  90.         public long getItemId(int position) {  
  91.             return 0;  
  92.         }  
  93.   
  94.         @Override  
  95.         public View getView(int position, View convertView, ViewGroup parent) {  
  96.             View view = convertView;  
  97.             ViewHolder vh;  
  98.             if(view == null) {  
  99.                 view = LayoutInflater.from(MainActivity.this).inflate(R.layout.list_item, null);  
  100.                 vh = new ViewHolder();  
  101.                 vh.tv = (TextView) view.findViewById(R.id.textView);  
  102.                 vh.iv = (ImageView) view.findViewById(R.id.imageView);  
  103.                 view.setTag(vh);  
  104.             }  
  105.             vh = (ViewHolder) view.getTag();  
  106.             vh.tv.setText((String) mData.get(position).get("title"));  
  107.             Bitmap bitmap = (Bitmap) mData.get(position).get("pic");  
  108.             if(bitmap != null) {  
  109.                 vh.iv.setImageBitmap(bitmap);  
  110.             }  
  111.             else {  
  112.                 vh.iv.setImageBitmap(null);  
  113.             }  
  114.               
  115.             AsyncTask task = (AsyncTask) mData.get(position).get("task");  
  116.             if(task == null || task.isCancelled()) {  
  117.                 mData.get(position).put("task", new GetItemImageTask(position).execute(null));//啟動線程異步獲取圖片  
  118.             }  
  119.               
  120.             return view;  
  121.         }  
  122.   
  123.           
  124.           
  125.     }  
  126.       
  127.     static class ViewHolder {  
  128.         TextView tv;  
  129.         ImageView iv;  
  130.     }  
  131.       
  132.       
  133.     class GetItemImageTask extends AsyncTask<Void, Void, Void> {//獲取圖片仍采用AsyncTask，這裏的優化放到下篇再討論  
  134.           
  135.         int id;  
  136.           
  137.         GetItemImageTask(int id) {  
  138.             this.id = id;  
  139.         }  
  140.   
  141.         @Override  
  142.         protected Void doInBackground(Void... params) {  
  143.               
  144.             Bitmap bm = (Bitmap) Data.getData(String.valueOf(id));  
  145.             if(bm != null) {//如果hashmap中已經有數據，  
  146.                 mData.get(id).put("pic", bm);  
  147.             }  
  148.             else {//模擬從網絡獲取  
  149.                 try {  
  150.                     Thread.sleep(200);//模擬網絡延時  
  151.                 } catch (InterruptedException e) {  
  152.                     e.printStackTrace();  
  153.                 }  
  154.                 mData.get(id).put("pic", BitmapFactory.decodeResource(getResources(), R.drawable.icon));  
  155.             }  
  156.             return null;  
  157.         }  
  158.           
  159.         protected void onPostExecute (Void result) {  
  160.             mAdapter.notifyDataSetChanged();  
  161.         }  
  162.           
  163.     }  
  164.       


Data.java 靜態的Hashmap保存預讀數據

 

  1. package com.zhuozhuo;  
  2.   
  3. import java.util.AbstractMap;  
  4. import java.util.HashMap;  
  5. import java.util.concurrent.ConcurrentHashMap;  
  6.   
  7. public class Data {  
  8.     private static AbstractMap<String, Object> mData = new ConcurrentHashMap<String, Object>();  
  9.       
  10.     private Data() {  
  11.           
  12.     }  
  13.       
  14.     public static void putData(String key,Object obj) {  
  15.         mData.put(key, obj);  
  16.     }  
  17.       
  18.     public static Object getData(String key) {  
  19.         return mData.get(key);  
  20.     }  
  21. }  

運行結果：



從執行結果可以看到，當進入MainActivity時，listview中的第一屏的圖片已經加載好了。

這個簡單例子中還不能很好地體現預讀帶來的用戶體驗的優勢，不過一些應用（如前麵提到過的新聞閱讀類應用），實現了預讀機製，使響應性大大提高，增強了用戶體驗。

總結：

1、通過實現自定義的AsyncTask來避免AsyncTask引起的FC風險和滿足特定的後台異步任務需求

2、實現後台預讀可以提高應用的響應性。

3、使用Executors.newSingleThreadExecutor()創建隻有一個工作隊列的線程池來實現預讀需求。

引申：

1、預讀隊列的工作線程可以不止一個，請根據需求配置自己的線程池。

2、adapter的getview()方法中，我們仍然采用了AsyncTask實現異步獲取圖片，下篇我們將探討更好的解決辦法，在提高響應性的同時，避免了AyncTask帶來的FC風險

3、預讀也要控製成本，存儲空間、耗電和流量都是要考慮的因素。


最後更新：2017-04-03 12:55:33

  上一篇：go Android中PopupWindow顯示在指定位置
  下一篇：go Oracle中計算日期之間相差的年月