自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

一套完善的Android異步任務類

作者：kymjs_張濤
移動開發(fā) Android
今天向大家介紹一個很有用的異步任務類處理類，分別包含了AsyncTask各個環(huán)節(jié)中的異常處理、大量并發(fā)執(zhí)行而不發(fā)生異常、字符串數(shù)據緩存等功能。并且感謝@馬天宇(http://litesuits.com/)給我的思路與指點。

[[123542]]

今天向大家介紹一個很有用的異步任務類處理類，分別包含了AsyncTask各個環(huán)節(jié)中的異常處理、大量并發(fā)執(zhí)行而不發(fā)生異常、字符串數(shù)據緩存等功能。并且感謝@馬天宇(http://litesuits.com/)給我的思路與指點。

研究過Android系統(tǒng)源碼的同學會發(fā)現(xiàn)：AsyncTask在android2.3的時候線程池是一個核心數(shù)為5線程，隊列可容納10線程，***執(zhí)行128個任務，這存在一個問題，當你真的有138個并發(fā)時，即使手機沒被你撐爆，那么超出這個指標應用絕對crash掉。 后來升級到3.0，為了避免并發(fā)帶來的一些列問題，AsyncTask竟然成為序列執(zhí)行器了，也就是你即使你同時execute N個AsyncTask，它也是挨個排隊執(zhí)行的。 這一點請同學們一定注意，AsyncTask在3.0以后，是異步的沒錯，但不是并發(fā)的。關于這一點的改進辦法，我之前寫過一篇《Thread并發(fā)請求封裝——深入理解AsyncTask類》沒有看過的同學可以看這里，本文是在這個基礎上對AsyncTask做進一步的優(yōu)化。

根據Android4.0源碼我們可以看到，在AsyncTask中默認有兩個執(zhí)行器，ThreadPoolExecutor和SerialExecutor，分別表示并行執(zhí)行器和串行執(zhí)行器。但是默認的并行執(zhí)行器并不能執(zhí)行大于128個任務的處理，所以我們在此定義一個根據lru調度策略的并行執(zhí)行器。源碼可以看這里。

  1. /** 
  2.     * 用于替換掉原生的mThreadPoolExecutor，可以大大改善Android自帶異步任務框架的處理能力和速度。 
  3.     * 默認使用LIFO（后進先出）策略來調度線程，可將***的任務快速執(zhí)行，當然你自己可以換為FIFO調度策略。 
  4.     * 這有助于用戶當前任務優(yōu)先完成（比如加載圖片時，很容易做到當前屏幕上的圖片優(yōu)先加載）。 
  5.     */ 
  6.    private static class SmartSerialExecutor implements Executor { 
  7.        /** 
  8.         * 這里使用{@link ArrayDequeCompat}作為棧比{@link Stack}性能高 
  9.         */ 
  10.        private ArrayDequeCompat<Runnable> mQueue = new ArrayDequeCompat<Runnable>( 
  11.                serialMaxCount); 
  12.        private ScheduleStrategy mStrategy = ScheduleStrategy.LIFO; 
  13.  
  14.        private enum ScheduleStrategy { 
  15.            LIFO, FIFO; 
  16.        } 
  17.  
  18.        /** 
  19.         * 一次同時并發(fā)的數(shù)量，根據處理器數(shù)量調節(jié) <br> 
  20.         * cpu count : 1 2 3 4 8 16 32 <br> 
  21.         * once(base*2): 1 2 3 4 8 16 32 <br> 
  22.         * 一個時間段內最多并發(fā)線程個數(shù)： 雙核手機：2 四核手機：4 ... 計算公式如下： 
  23.         */ 
  24.        private static int serialOneTime; 
  25.        /** 
  26.         * 并發(fā)***數(shù)量，當投入的任務過多大于此值時，根據Lru規(guī)則，將最老的任務移除（將得不到執(zhí)行） <br> 
  27.         * cpu count : 1 2 3 4 8 16 32 <br> 
  28.         * base(cpu+3) : 4 5 6 7 11 19 35 <br> 
  29.         * max(base*16): 64 80 96 112 176 304 560 <br> 
  30.         */ 
  31.        private static int serialMaxCount; 
  32.  
  33.        private void reSettings(int cpuCount) { 
  34.            serialOneTime = cpuCount; 
  35.            serialMaxCount = (cpuCount + 3) * 16; 
  36.        } 
  37.        public SmartSerialExecutor() { 
  38.            reSettings(CPU_COUNT); 
  39.        } 
  40.        @Override 
  41.        public synchronized void execute(final Runnable command) { 
  42.            Runnable r = new Runnable() { 
  43.                @Override 
  44.                public void run() { 
  45.                    command.run(); 
  46.                    next(); 
  47.                } 
  48.            }; 
  49.            if ((mThreadPoolExecutor).getActiveCount() < serialOneTime) { 
  50.                // 小于單次并發(fā)量直接運行 
  51.                mThreadPoolExecutor.execute(r); 
  52.            } else { 
  53.                // 如果大于并發(fā)上限，那么移除最老的任務 
  54.                if (mQueue.size() >= serialMaxCount) { 
  55.                    mQueue.pollFirst(); 
  56.                } 
  57.                // 新任務放在隊尾 
  58.                mQueue.offerLast(r); 
  59.            } 
  60.        } 
  61.        public synchronized void next() { 
  62.            Runnable mActive; 
  63.            switch (mStrategy) { 
  64.            case LIFO: 
  65.                mActive = mQueue.pollLast(); 
  66.                break; 
  67.            case FIFO: 
  68.                mActive = mQueue.pollFirst(); 
  69.                break; 
  70.            default: 
  71.                mActive = mQueue.pollLast(); 
  72.                break; 
  73.            } 
  74.            if (mActive != null) { 
  75.                mThreadPoolExecutor.execute(mActive); 
  76.            } 
  77.        } 
  78.    } 

以上便是對AsyncTask的并發(fā)執(zhí)行優(yōu)化，接下來我們看對異常捕獲的改進。

真正說起來，這并不算是什么功能上的改進，僅僅是一種開發(fā)上的技巧。代碼過長，我刪去了一些，僅留下重要部分。

  1. /** 
  2.  * 安全異步任務，可以捕獲任意異常，并反饋給給開發(fā)者。<br> 
  3.  * 從執(zhí)行前，執(zhí)行中，執(zhí)行后，乃至更新時的異常都捕獲。<br> 
  4.  */ 
  5. public abstract class SafeTask<Params, Progress, Result> extends 
  6.         KJTaskExecutor<Params, Progress, Result> { 
  7.     private Exception cause; 
  8.   
  9.     @Override 
  10.     protected final void onPreExecute() { 
  11.         try { 
  12.             onPreExecuteSafely(); 
  13.         } catch (Exception e) { 
  14.             exceptionLog(e); 
  15.         } 
  16.     } 
  17.     @Override 
  18.     protected final Result doInBackground(Params... params) { 
  19.         try { 
  20.             return doInBackgroundSafely(params); 
  21.         } catch (Exception e) { 
  22.             exceptionLog(e); 
  23.             cause = e; 
  24.         } 
  25.         return null; 
  26.     } 
  27.     @Override 
  28.     protected final void onProgressUpdate(Progress... values) { 
  29.         try { 
  30.             onProgressUpdateSafely(values); 
  31.         } catch (Exception e) { 
  32.             exceptionLog(e); 
  33.         } 
  34.     } 
  35.     @Override 
  36.     protected final void onPostExecute(Result result) { 
  37.         try { 
  38.             onPostExecuteSafely(result, cause); 
  39.         } catch (Exception e) { 
  40.             exceptionLog(e); 
  41.         } 
  42.     } 
  43.     @Override 
  44.     protected final void onCancelled(Result result) { 
  45.         onCancelled(result); 
  46.     } 
  47. } 

其實從代碼就可以看出，僅僅是對原AsyncTask類中各個階段的代碼做了一次try..catch... 但就是這一個小優(yōu)化，不僅可以使代碼整齊(我覺得try...catch太多真的很影響代碼美觀)，而且在最終都可以由一個onPostExecuteSafely(xxx)來整合處理，使得結構更加緊湊。

讓AsyncTask附帶數(shù)據緩存功能

我們在做APP開發(fā)的時候，網絡訪問都會加上緩存處理，其中的原因我想就不必講了。那么如果讓AsyncTask自身就附帶網絡JSON緩存，豈不是更好？其實實現(xiàn)原理很簡單，就是將平時我們寫在外面的緩存方法放到AsyncTask內部去實現(xiàn)，注釋已經講解的很清楚了，這里就不再講了

  1. /** 
  2.  * 本類主要用于獲取網絡數(shù)據，并將結果緩存至文件，文件名為key，緩存有效時間為value <br> 
  3.  * <b>注：</b>{@link #CachedTask#Result}需要序列化，否則不能或者不能完整的讀取緩存。<br> 
  4.  */ 
  5. public abstract class CachedTask<Params, Progress, Result extends Serializable> 
  6.         extends SafeTask<Params, Progress, Result> { 
  7.     private String cachePath = "folderName"; // 緩存路徑 
  8.     private String cacheName = "MD5_effectiveTime"; // 緩存文件名格式 
  9.     private long expiredTime = 0; // 緩存時間 
  10.     private String key; // 緩存以鍵值對形式存在 
  11.     private ConcurrentHashMap<String, Long> cacheMap; 
  12.   
  13.     /** 
  14.      * 構造方法 
  15.      * @param cachePath  緩存路徑 
  16.      * @param key  存儲的key值，若重復將覆蓋 
  17.      * @param cacheTime  緩存有效期，單位：分 
  18.      */ 
  19.     public CachedTask(String cachePath, String key, long cacheTime) { 
  20.         if (StringUtils.isEmpty(cachePath) 
  21.                 || StringUtils.isEmpty(key)) { 
  22.             throw new RuntimeException("cachePath or key is empty"); 
  23.         } else { 
  24.             this.cachePath = cachePath; 
  25.             // 對外url，對內url的md5值（不僅可以防止由于url過長造成文件名錯誤，還能防止惡意修改緩存內容） 
  26.             this.key = CipherUtils.md5(key); 
  27.             // 對外單位：分，對內單位：毫秒 
  28.             this.expiredTime = TimeUnit.MILLISECONDS.convert( 
  29.                     cacheTime, TimeUnit.MINUTES); 
  30.             this.cacheName = this.key + "_" + cacheTime; 
  31.             initCacheMap(); 
  32.         } 
  33.     } 
  34.   
  35.     private void initCacheMap() { 
  36.         cacheMap = new ConcurrentHashMap<String, Long>(); 
  37.         File folder = FileUtils.getSaveFolder(cachePath); 
  38.         for (String name : folder.list()) { 
  39.             if (!StringUtils.isEmpty(name)) { 
  40.                 String[] nameFormat = name.split("_"); 
  41.                 // 若滿足命名格式則認為是一個合格的cache 
  42.                 if (nameFormat.length == 2 && (nameFormat[0].length() == 32 || nameFormat[0].length() == 64 || nameFormat[0].length() == 128)) { 
  43.                     cacheMap.put(nameFormat[0], TimeUnit.MILLISECONDS.convert(StringUtils.toLong(nameFormat[1]), TimeUnit.MINUTES)); 
  44.                 } 
  45.             } 
  46.         } 
  47.     } 
  48.   
  49.     /** 
  50.      * 做聯(lián)網操作,本方法運行在線程中 
  51.      */ 
  52.     protected abstract Result doConnectNetwork(Params... params) 
  53.             throws Exception; 
  54.   
  55.     /** 
  56.      * 做耗時操作 
  57.      */ 
  58.     @Override 
  59.     protected final Result doInBackgroundSafely(Params... params) 
  60.             throws Exception { 
  61.         Result res = null; 
  62.         Long time = cacheMap.get(key); 
  63.         long lastTime = (time == null) ? 0 : time; // 獲取緩存有效時間 
  64.         long currentTime = System.currentTimeMillis(); // 獲取當前時間 
  65.   
  66.         if (currentTime >= lastTime + expiredTime) { // 若緩存無效，聯(lián)網下載 
  67.             res = doConnectNetwork(params); 
  68.             if (res == null)  
  69.                 res = getResultFromCache(); 
  70.             else  
  71.                 saveCache(res); 
  72.         } else { // 緩存有效，使用緩存 
  73.             res = getResultFromCache(); 
  74.             if (res == null) { // 若緩存數(shù)據意外丟失，重新下載 
  75.                 res = doConnectNetwork(params); 
  76.                 saveCache(res); 
  77.             } 
  78.         } 
  79.         return res; 
  80.     } 
  81.   
  82.     private Result getResultFromCache() { 
  83.         Result res = null; 
  84.         ObjectInputStream ois = null; 
  85.         try { 
  86.             ois = new ObjectInputStream(new FileInputStream( 
  87.                     FileUtils.getSaveFile(cachePath, key))); 
  88.             res = (Result) ois.readObject(); 
  89.         } catch (Exception e) { 
  90.             e.printStackTrace(); 
  91.         } finally { 
  92.             FileUtils.closeIO(ois); 
  93.         } 
  94.         return res; 
  95.     } 
  96.   
  97.     /** 
  98.      * 保存數(shù)據，并返回是否成功 
  99.      */ 
  100.     private boolean saveResultToCache(Result res) { 
  101.         boolean saveSuccess = false; 
  102.         ObjectOutputStream oos = null; 
  103.         try { 
  104.             oos = new ObjectOutputStream(new FileOutputStream( 
  105.                     FileUtils.getSaveFile(cachePath, key))); 
  106.             oos.writeObject(res); 
  107.             saveSuccess = true; 
  108.         } catch (Exception e) { 
  109.             e.printStackTrace(); 
  110.         } finally { 
  111.             FileUtils.closeIO(oos); 
  112.         } 
  113.         return saveSuccess; 
  114.     } 
  115.   
  116.     /** 
  117.      * 清空緩存文件（異步） 
  118.      */ 
  119.     public void cleanCacheFiles() { 
  120.         cacheMap.clear(); 
  121.         File file = FileUtils.getSaveFolder(cachePath); 
  122.         final File[] fileList = file.listFiles(); 
  123.         if (fileList != null) { 
  124.             // 異步刪除全部文件 
  125.             TaskExecutor.start(new Runnable() { 
  126.                 @Override 
  127.                 public void run() { 
  128.                     for (File f : fileList) { 
  129.                         if (f.isFile()) { 
  130.                             f.delete(); 
  131.                         } 
  132.                     } 
  133.                 }// end run() 
  134.             }); 
  135.         }// end if 
  136.     } 
  137.   
  138.     /** 
  139.      * 移除一個緩存 
  140.      */ 
  141.     public void remove(String key) { 
  142.         // 對內是url的MD5 
  143.         String realKey = CipherUtils.md5(key); 
  144.         for (Map.Entry<String, Long> entry : cacheMap.entrySet()) { 
  145.             if (entry.getKey().startsWith(realKey)) { 
  146.                 cacheMap.remove(realKey); 
  147.                 return; 
  148.             } 
  149.         } 
  150.     } 
  151.   
  152.     /** 
  153.      * 如果緩存是有效的，就保存 
  154.      * @param res 將要緩存的數(shù)據 
  155.      */ 
  156.     private void saveCache(Result res) { 
  157.         if (res != null) { 
  158.             saveResultToCache(res); 
  159.             cacheMap.put(cacheName, System.currentTimeMillis()); 
  160.         } 
  161.     } 
  162. } 

 

責任編輯：chenqingxiang 來源： oschina
Android異步任務
相關推薦

2024-12-09 09:25:30

2024-09-23 04:00:00

java架構分布式系統(tǒng)

2009-06-23 18:01:45

Ajax框架源代碼

2018-08-31 08:42:48

LinuxUnix實用程序

2023-03-03 17:00:00

部署Linux內核

2019-10-11 15:58:25

戴爾

2021-05-27 07:12:19

單點登錄系統(tǒng)

2021-03-29 11:20:39

前端代碼工作流

2025-04-07 07:45:00

AI模型神經網絡

2010-06-09 17:00:43

UML試題

2024-11-19 16:31:23

2022-02-25 09:00:00

數(shù)據科學工具架構

2024-11-12 08:13:09

2020-12-08 08:12:14

SQL腳本行轉列

2010-12-24 11:27:13

華為HCNE認證

2018-03-19 15:22:43

Android圖標包圖標

2020-06-30 15:33:05

Linux 系統(tǒng) 數(shù)據

2009-09-22 17:12:22

計算機原理教材

2021-05-06 11:06:52

人工智能語音識別聲聞檢索

2024-03-06 08:13:33

FutureJDKCallable
點贊
收藏

51CTO技術棧公眾號