一套完善的Android異步任務(wù)類

作者：kymjs_張濤 2014-12-02 10:02:21

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

[[123542]]

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

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

/** 
    * 用于替換掉原生的mThreadPoolExecutor，可以大大改善Android自帶異步任務(wù)框架的處理能力和速度。 
    * 默認(rèn)使用LIFO（后進先出）策略來調(diào)度線程，可將***的任務(wù)快速執(zhí)行，當(dāng)然你自己可以換為FIFO調(diào)度策略。 
    * 這有助于用戶當(dāng)前任務(wù)優(yōu)先完成（比如加載圖片時，很容易做到當(dāng)前屏幕上的圖片優(yōu)先加載）。 
    */ 
   private static class SmartSerialExecutor implements Executor { 
       /** 
        * 這里使用{@link ArrayDequeCompat}作為棧比{@link Stack}性能高 
        */ 
       private ArrayDequeCompat<Runnable> mQueue = new ArrayDequeCompat<Runnable>( 
               serialMaxCount); 
       private ScheduleStrategy mStrategy = ScheduleStrategy.LIFO; 
 
       private enum ScheduleStrategy { 
           LIFO, FIFO; 
       } 
 
       /** 
        * 一次同時并發(fā)的數(shù)量，根據(jù)處理器數(shù)量調(diào)節(jié) <br> 
        * cpu count : 1 2 3 4 8 16 32 <br> 
        * once(base*2): 1 2 3 4 8 16 32 <br> 
        * 一個時間段內(nèi)最多并發(fā)線程個數(shù)： 雙核手機：2 四核手機：4 ... 計算公式如下： 
        */ 
       private static int serialOneTime; 
       /** 
        * 并發(fā)***數(shù)量，當(dāng)投入的任務(wù)過多大于此值時，根據(jù)Lru規(guī)則，將最老的任務(wù)移除（將得不到執(zhí)行） <br> 
        * cpu count : 1 2 3 4 8 16 32 <br> 
        * base(cpu+3) : 4 5 6 7 11 19 35 <br> 
        * max(base*16): 64 80 96 112 176 304 560 <br> 
        */ 
       private static int serialMaxCount; 
 
       private void reSettings(int cpuCount) { 
           serialOneTime = cpuCount; 
           serialMaxCount = (cpuCount + 3) * 16; 
       } 
       public SmartSerialExecutor() { 
           reSettings(CPU_COUNT); 
       } 
       @Override 
       public synchronized void execute(final Runnable command) { 
           Runnable r = new Runnable() { 
               @Override 
               public void run() { 
                   command.run(); 
                   next(); 
               } 
           }; 
           if ((mThreadPoolExecutor).getActiveCount() < serialOneTime) { 
               // 小于單次并發(fā)量直接運行 
               mThreadPoolExecutor.execute(r); 
           } else { 
               // 如果大于并發(fā)上限，那么移除最老的任務(wù) 
               if (mQueue.size() >= serialMaxCount) { 
                   mQueue.pollFirst(); 
               } 
               // 新任務(wù)放在隊尾 
               mQueue.offerLast(r); 
           } 
       } 
       public synchronized void next() { 
           Runnable mActive; 
           switch (mStrategy) { 
           case LIFO: 
               mActive = mQueue.pollLast(); 
               break; 
           case FIFO: 
               mActive = mQueue.pollFirst(); 
               break; 
           default: 
               mActive = mQueue.pollLast(); 
               break; 
           } 
           if (mActive != null) { 
               mThreadPoolExecutor.execute(mActive); 
           } 
       } 
   }

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

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

/** 
 * 安全異步任務(wù)，可以捕獲任意異常，并反饋給給開發(fā)者。<br> 
 * 從執(zhí)行前，執(zhí)行中，執(zhí)行后，乃至更新時的異常都捕獲。<br> 
 */ 
public abstract class SafeTask<Params, Progress, Result> extends 
        KJTaskExecutor<Params, Progress, Result> { 
    private Exception cause; 
  
    @Override 
    protected final void onPreExecute() { 
        try { 
            onPreExecuteSafely(); 
        } catch (Exception e) { 
            exceptionLog(e); 
        } 
    } 
    @Override 
    protected final Result doInBackground(Params... params) { 
        try { 
            return doInBackgroundSafely(params); 
        } catch (Exception e) { 
            exceptionLog(e); 
            cause = e; 
        } 
        return null; 
    } 
    @Override 
    protected final void onProgressUpdate(Progress... values) { 
        try { 
            onProgressUpdateSafely(values); 
        } catch (Exception e) { 
            exceptionLog(e); 
        } 
    } 
    @Override 
    protected final void onPostExecute(Result result) { 
        try { 
            onPostExecuteSafely(result, cause); 
        } catch (Exception e) { 
            exceptionLog(e); 
        } 
    } 
    @Override 
    protected final void onCancelled(Result result) { 
        onCancelled(result); 
    } 
}

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

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

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

/** 
 * 本類主要用于獲取網(wǎng)絡(luò)數(shù)據(jù)，并將結(jié)果緩存至文件，文件名為key，緩存有效時間為value <br> 
 * <b>注：</b>{@link #CachedTask#Result}需要序列化，否則不能或者不能完整的讀取緩存。<br> 
 */ 
public abstract class CachedTask<Params, Progress, Result extends Serializable> 
        extends SafeTask<Params, Progress, Result> { 
    private String cachePath = "folderName"; // 緩存路徑 
    private String cacheName = "MD5_effectiveTime"; // 緩存文件名格式 
    private long expiredTime = 0; // 緩存時間 
    private String key; // 緩存以鍵值對形式存在 
    private ConcurrentHashMap<String, Long> cacheMap; 
  
    /** 
     * 構(gòu)造方法 
     * @param cachePath  緩存路徑 
     * @param key  存儲的key值，若重復(fù)將覆蓋 
     * @param cacheTime  緩存有效期，單位：分 
     */ 
    public CachedTask(String cachePath, String key, long cacheTime) { 
        if (StringUtils.isEmpty(cachePath) 
                || StringUtils.isEmpty(key)) { 
            throw new RuntimeException("cachePath or key is empty"); 
        } else { 
            this.cachePath = cachePath; 
            // 對外url，對內(nèi)url的md5值（不僅可以防止由于url過長造成文件名錯誤，還能防止惡意修改緩存內(nèi)容） 
            this.key = CipherUtils.md5(key); 
            // 對外單位：分，對內(nèi)單位：毫秒 
            this.expiredTime = TimeUnit.MILLISECONDS.convert( 
                    cacheTime, TimeUnit.MINUTES); 
            this.cacheName = this.key + "_" + cacheTime; 
            initCacheMap(); 
        } 
    } 
  
    private void initCacheMap() { 
        cacheMap = new ConcurrentHashMap<String, Long>(); 
        File folder = FileUtils.getSaveFolder(cachePath); 
        for (String name : folder.list()) { 
            if (!StringUtils.isEmpty(name)) { 
                String[] nameFormat = name.split("_"); 
                // 若滿足命名格式則認(rèn)為是一個合格的cache 
                if (nameFormat.length == 2 && (nameFormat[0].length() == 32 || nameFormat[0].length() == 64 || nameFormat[0].length() == 128)) { 
                    cacheMap.put(nameFormat[0], TimeUnit.MILLISECONDS.convert(StringUtils.toLong(nameFormat[1]), TimeUnit.MINUTES)); 
                } 
            } 
        } 
    } 
  
    /** 
     * 做聯(lián)網(wǎng)操作,本方法運行在線程中 
     */ 
    protected abstract Result doConnectNetwork(Params... params) 
            throws Exception; 
  
    /** 
     * 做耗時操作 
     */ 
    @Override 
    protected final Result doInBackgroundSafely(Params... params) 
            throws Exception { 
        Result res = null; 
        Long time = cacheMap.get(key); 
        long lastTime = (time == null) ? 0 : time; // 獲取緩存有效時間 
        long currentTime = System.currentTimeMillis(); // 獲取當(dāng)前時間 
  
        if (currentTime >= lastTime + expiredTime) { // 若緩存無效，聯(lián)網(wǎng)下載 
            res = doConnectNetwork(params); 
            if (res == null)  
                res = getResultFromCache(); 
            else  
                saveCache(res); 
        } else { // 緩存有效，使用緩存 
            res = getResultFromCache(); 
            if (res == null) { // 若緩存數(shù)據(jù)意外丟失，重新下載 
                res = doConnectNetwork(params); 
                saveCache(res); 
            } 
        } 
        return res; 
    } 
  
    private Result getResultFromCache() { 
        Result res = null; 
        ObjectInputStream ois = null; 
        try { 
            ois = new ObjectInputStream(new FileInputStream( 
                    FileUtils.getSaveFile(cachePath, key))); 
            res = (Result) ois.readObject(); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } finally { 
            FileUtils.closeIO(ois); 
        } 
        return res; 
    } 
  
    /** 
     * 保存數(shù)據(jù)，并返回是否成功 
     */ 
    private boolean saveResultToCache(Result res) { 
        boolean saveSuccess = false; 
        ObjectOutputStream oos = null; 
        try { 
            oos = new ObjectOutputStream(new FileOutputStream( 
                    FileUtils.getSaveFile(cachePath, key))); 
            oos.writeObject(res); 
            saveSuccess = true; 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } finally { 
            FileUtils.closeIO(oos); 
        } 
        return saveSuccess; 
    } 
  
    /** 
     * 清空緩存文件（異步） 
     */ 
    public void cleanCacheFiles() { 
        cacheMap.clear(); 
        File file = FileUtils.getSaveFolder(cachePath); 
        final File[] fileList = file.listFiles(); 
        if (fileList != null) { 
            // 異步刪除全部文件 
            TaskExecutor.start(new Runnable() { 
                @Override 
                public void run() { 
                    for (File f : fileList) { 
                        if (f.isFile()) { 
                            f.delete(); 
                        } 
                    } 
                }// end run() 
            }); 
        }// end if 
    } 
  
    /** 
     * 移除一個緩存 
     */ 
    public void remove(String key) { 
        // 對內(nèi)是url的MD5 
        String realKey = CipherUtils.md5(key); 
        for (Map.Entry<String, Long> entry : cacheMap.entrySet()) { 
            if (entry.getKey().startsWith(realKey)) { 
                cacheMap.remove(realKey); 
                return; 
            } 
        } 
    } 
  
    /** 
     * 如果緩存是有效的，就保存 
     * @param res 將要緩存的數(shù)據(jù) 
     */ 
    private void saveCache(Result res) { 
        if (res != null) { 
            saveResultToCache(res); 
            cacheMap.put(cacheName, System.currentTimeMillis()); 
        } 
    } 
}

責(zé)任編輯：chenqingxiang 來源： oschina

Android 異步任務(wù)