一套完善的Android异步任务类

今天向大家介绍一个很有用的异步任务类处理类，分别包含了AsyncTask各个环节中的异常处理、大量并发执行而不发生异常、字符串数据缓存等功能。并且感谢@马天宇(http://litesuits.com/)给我的思路与指点。

创新互联公司为客户提供专业的成都做网站、成都网站制作、程序、域名、空间一条龙服务，提供基于WEB的系统开发. 服务项目涵盖了网页设计、网站程序开发、WEB系统开发、微信二次开发、成都手机网站制作等网站方面业务。

研究过Android系统源码的同学会发现：AsyncTask在android2.3的时候线程池是一个核心数为5线程，队列可容纳10线程，***执行128个任务，这存在一个问题，当你真的有138个并发时，即使手机没被你撑爆，那么超出这个指标应用绝对crash掉。 后来升级到3.0，为了避免并发带来的一些列问题，AsyncTask竟然成为序列执行器了，也就是你即使你同时execute N个AsyncTask，它也是挨个排队执行的。 这一点请同学们一定注意，AsyncTask在3.0以后，是异步的没错，但不是并发的。关于这一点的改进办法，我之前写过一篇《Thread并发请求封装——深入理解AsyncTask类》没有看过的同学可以看这里，本文是在这个基础上对AsyncTask做进一步的优化。

根据Android4.0源码我们可以看到，在AsyncTask中默认有两个执行器，ThreadPoolExecutor和SerialExecutor，分别表示并行执行器和串行执行器。但是默认的并行执行器并不能执行大于128个任务的处理，所以我们在此定义一个根据lru调度策略的并行执行器。源码可以看这里。

 
 
 
    
  
  
  
  1. /** 
    2. 
  
  
  
  2.     * 用于替换掉原生的mThreadPoolExecutor，可以大大改善Android自带异步任务框架的处理能力和速度。 
    3. 
  
  
  
  3.     * 默认使用LIFO（后进先出）策略来调度线程，可将***的任务快速执行，当然你自己可以换为FIFO调度策略。 
    4. 
  
  
  
  4.     * 这有助于用户当前任务优先完成（比如加载图片时，很容易做到当前屏幕上的图片优先加载）。 
    5. 
  
  
  
  5.     */ 
    6. 
  
  
  
  6.    private static class SmartSerialExecutor implements Executor { 
    7. 
  
  
  
  7.        /** 
    8. 
  
  
  
  8.         * 这里使用{@link ArrayDequeCompat}作为栈比{@link Stack}性能高 
    9. 
  
  
  
  9.         */ 
    10. 
  
  
  
  10.        private ArrayDequeCompat mQueue = new ArrayDequeCompat( 
    11. 
  
  
  
  11.                serialMaxCount); 
    12. 
  
  
  
  12.        private ScheduleStrategy mStrategy = ScheduleStrategy.LIFO; 
    13. 
  
  
  
  13.  
    14. 
  
  
  
  14.        private enum ScheduleStrategy { 
    15. 
  
  
  
  15.            LIFO, FIFO; 
    16. 
  
  
  
  16.        } 
    17. 
  
  
  
  17.  
    18. 
  
  
  
  18.        /** 
    19. 
  
  
  
  19.         * 一次同时并发的数量，根据处理器数量调节 
     
    20. 
  
  
  
  20.         * cpu count : 1 2 3 4 8 16 32 
     
    21. 
  
  
  
  21.         * once(base*2): 1 2 3 4 8 16 32 
     
    22. 
  
  
  
  22.         * 一个时间段内最多并发线程个数： 双核手机：2 四核手机：4 ... 计算公式如下： 
    23. 
  
  
  
  23.         */ 
    24. 
  
  
  
  24.        private static int serialOneTime; 
    25. 
  
  
  
  25.        /** 
    26. 
  
  
  
  26.         * 并发***数量，当投入的任务过多大于此值时，根据Lru规则，将最老的任务移除（将得不到执行） 
     
    27. 
  
  
  
  27.         * cpu count : 1 2 3 4 8 16 32 
     
    28. 
  
  
  
  28.         * base(cpu+3) : 4 5 6 7 11 19 35 
     
    29. 
  
  
  
  29.         * max(base*16): 64 80 96 112 176 304 560 
     
    30. 
  
  
  
  30.         */ 
    31. 
  
  
  
  31.        private static int serialMaxCount; 
    32. 
  
  
  
  32.  
    33. 
  
  
  
  33.        private void reSettings(int cpuCount) { 
    34. 
  
  
  
  34.            serialOneTime = cpuCount; 
    35. 
  
  
  
  35.            serialMaxCount = (cpuCount + 3) * 16; 
    36. 
  
  
  
  36.        } 
    37. 
  
  
  
  37.        public SmartSerialExecutor() { 
    38. 
  
  
  
  38.            reSettings(CPU_COUNT); 
    39. 
  
  
  
  39.        } 
    40. 
  
  
  
  40.        @Override 
    41. 
  
  
  
  41.        public synchronized void execute(final Runnable command) { 
    42. 
  
  
  
  42.            Runnable r = new Runnable() { 
    43. 
  
  
  
  43.                @Override 
    44. 
  
  
  
  44.                public void run() { 
    45. 
  
  
  
  45.                    command.run(); 
    46. 
  
  
  
  46.                    next(); 
    47. 
  
  
  
  47.                } 
    48. 
  
  
  
  48.            }; 
    49. 
  
  
  
  49.            if ((mThreadPoolExecutor).getActiveCount() < serialOneTime) { 
    50. 
  
  
  
  50.                // 小于单次并发量直接运行 
    51. 
  
  
  
  51.                mThreadPoolExecutor.execute(r); 
    52. 
  
  
  
  52.            } else { 
    53. 
  
  
  
  53.                // 如果大于并发上限，那么移除最老的任务 
    54. 
  
  
  
  54.                if (mQueue.size() >= serialMaxCount) { 
    55. 
  
  
  
  55.                    mQueue.pollFirst(); 
    56. 
  
  
  
  56.                } 
    57. 
  
  
  
  57.                // 新任务放在队尾 
    58. 
  
  
  
  58.                mQueue.offerLast(r); 
    59. 
  
  
  
  59.            } 
    60. 
  
  
  
  60.        } 
    61. 
  
  
  
  61.        public synchronized void next() { 
    62. 
  
  
  
  62.            Runnable mActive; 
    63. 
  
  
  
  63.            switch (mStrategy) { 
    64. 
  
  
  
  64.            case LIFO: 
    65. 
  
  
  
  65.                mActive = mQueue.pollLast(); 
    66. 
  
  
  
  66.                break; 
    67. 
  
  
  
  67.            case FIFO: 
    68. 
  
  
  
  68.                mActive = mQueue.pollFirst(); 
    69. 
  
  
  
  69.                break; 
    70. 
  
  
  
  70.            default: 
    71. 
  
  
  
  71.                mActive = mQueue.pollLast(); 
    72. 
  
  
  
  72.                break; 
    73. 
  
  
  
  73.            } 
    74. 
  
  
  
  74.            if (mActive != null) { 
    75. 
  
  
  
  75.                mThreadPoolExecutor.execute(mActive); 
    76. 
  
  
  
  76.            } 
    77. 
  
  
  
  77.        } 
    78. 
  
  
  
  78.    } 
    79.

以上便是对AsyncTask的并发执行优化，接下来我们看对异常捕获的改进。

真正说起来，这并不算是什么功能上的改进，仅仅是一种开发上的技巧。代码过长，我删去了一些，仅留下重要部分。

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

其实从代码就可以看出，仅仅是对原AsyncTask类中各个阶段的代码做了一次try..catch... 但就是这一个小优化，不仅可以使代码整齐(我觉得try...catch太多真的很影响代码美观)，而且在最终都可以由一个onPostExecuteSafely(xxx)来整合处理，使得结构更加紧凑。

让AsyncTask附带数据缓存功能

我们在做APP开发的时候，网络访问都会加上缓存处理，其中的原因我想就不必讲了。那么如果让AsyncTask自身就附带网络JSON缓存，岂不是更好？其实实现原理很简单，就是将平时我们写在外面的缓存方法放到AsyncTask内部去实现，注释已经讲解的很清楚了，这里就不再讲了

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

网站栏目：一套完善的Android异步任务类
分享地址：http://www.csdahua.cn/qtweb/news32/32.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

用户体验知识

行业网站建设

眉山服务器托管　　 　四川國際商會　　 　正泰动物　　 　成都网站设计　　 　全网整合营销　　 　平山县网站建设　　 　Android开发　　 　域名申请　　 　成都品牌网站建设　　 　界面设计　　 　定制网站设计　　 　重庆托管服务器　　 　网站建设开发　　 　手机网站建设　　 　重庆手机网站建设　　 　注册域名　　 　成都网站维护　　 　天泽尚品装饰　　 　雪茄烟品牌　　 　成都微信公众号开发