注册 登录  
 加关注
查看详情
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

是缘是情是童真

如果你用笑脸面对 你会看见别人的笑脸

 
 
 

日志

 
 

Android多线程任务优化2:实现后台预读线程  

2011-10-10 14:42:11|  分类: 默认分类 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

导语:从上一篇《多线程任务的优化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、预读也要控制成本,存储空间、耗电和流量都是要考虑的因素。

 

转载自:http://blog.csdn.net/mylzc

  评论这张
 
阅读(1584)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2018