码迷，mamicode.com
首页 > 移动开发 > 详细

Java Design Demo -简单的队列-异步多任务队列（java android）

时间：2015-09-19 15:14:52      阅读：349      评论：0      收藏：0      [点我收藏+]

标签：

简单的单线程队列 -- 工作的时候遇到劣质打印机。给打印机发消息，打印机就会打印，如果在打印机还在打印的时候，就

再发消息打印，就会出现消息丢失。所以需要给上一个任务一些处理的间隔时间.

单线程的消息队列示例

 

[java] view plaincopyprint?
 
  1. package demo1;  
  2.   
  3. import java.util.LinkedList;  
  4.   
  5. public class Main {  
  6.   
  7.     /** 
  8.      * @param args 
  9.      */  
  10.   
  11.     private static Thread thread;  
  12.     private static LinkedList<Runnable> list = new LinkedList<Runnable>();  
  13.   
  14.     static int test = 0;  
  15.   
  16.     public static void main(String[] args) {  
  17.         // TODO Auto-generated method stub  
  18.         final long time = System.currentTimeMillis();  
  19.         for (int i = 0; i < 20; i++) {  
  20.   
  21.             tastEvent(new Runnable() {  
  22.                 public void run() {  
  23.   
  24.   
  25.                         try {  
  26.                             Thread.sleep(500);  
  27.                         } catch (InterruptedException e) {  
  28.                             // TODO Auto-generated catch block  
  29.                             e.printStackTrace();  
  30.                         }  
  31.   
  32.                         System.out  
  33.                                 .println("第"  
  34.                                         + (++test)  
  35.                                         + ("个任务  耗时:" + (System  
  36.                                                 .currentTimeMillis() - time)));  
  37.                     }  
  38.   
  39.             });  
  40.         }  
  41.     }  
  42.   
  43.     public static void tastEvent(Runnable r) {  
  44.         synchronized (list) {  
  45.             list.add(r);  
  46.         }  
  47.             if (thread == null) {  
  48.                 thread = new Thread(run);  
  49.                 thread.start();  
  50.             }  
  51.   
  52.   
  53.     }  
  54.   
  55.     static Runnable run = new Runnable() {  
  56.   
  57.         @Override  
  58.         public void run() {  
  59.             // TODO Auto-generated method stub  
  60.             synchronized (list) {  
  61.   
  62.                 while (!list.isEmpty()) {  
  63.                     // new Thread(list.poll()).start();  
  64.                     list.poll().run();  
  65.                 }  
  66.                 thread = null;  
  67.             }  
  68.         }  
  69.     };  
  70.   
  71. }  


技术分享

 

 

工作的时候遇到非常大的并发的情况，比如机器1秒只支持1000的并发，但是1秒接收了4000的并发。服务器就会崩掉。

最好将并发放到队列中，按1000的并发吞吐量来处理，这就是异步队列应用。

 

一个工程交给一个人做，需要花费3个月，交给2个人做，需要2个人做需要2个月，需要3个人做需要1个月半.....100.人.....1000人,几年也完不成。

带上以上道理看待以下的代码

 

观察以下代码（复制到android工程下运行）：最后耗时约1600毫秒 而使用android的AsyncTask类来改写这段代码只需要耗时约200 

 

 

[java] view plaincopyprint?
 
  1. final long  timer=System.currentTimeMillis();  
  2. count=0;  
  3. final Handler h=new Handler();  
  4. for(int k=0;k<100;k++){  
  5. new Thread(){  
  6.     @Override  
  7.     public void run() {  
  8.         // TODO Auto-generated method stub  
  9.         try {  
  10.             Thread.sleep(10);  
  11.         } catch (InterruptedException e) {  
  12.             // TODO Auto-generated catch block  
  13.             e.printStackTrace();  
  14.         }  
  15.         h.post(new Runnable() {  
  16.             @Override  
  17.             public void run() {  
  18.                 Toast.makeText(getApplicationContext()," 耗时"+ (System.currentTimeMillis() - timer), 1).show();  
  19.                 System.err.println("编号"+(count++)+"线程消耗了"+(System.currentTimeMillis()-timer));  
  20.             }  
  21.         });  
  22.     }  
  23. }.start();  



 

 

可见增加多线程不提高性能，反而因为系统在不同的线程之间切换降低效率。因此我们需要让线程有序执行任务

以下是异步多线程处理队列的demo

 

技术分享

 

[java] view plaincopyprint?
 
  1. package demo2;  
  2.   
  3. import demo2.Task.OnFinishListen;  
  4.   
  5. public class Main {  
  6.   
  7.     /** 
  8.      * @param args 
  9.      */  
  10.     public static void main(String[] args) {  
  11.         // TODO Auto-generated method stub  
  12.           
  13.         Task.setThreadMaxNum(3);  
  14.         for (int i = 0; i < 15; i++) {  
  15.             new Task() {  
  16.   
  17.                 @Override  
  18.                 public Object obtainData(Task task, Object parameter)  
  19.                         throws Exception {  
  20.                     // TODO Auto-generated method stub  
  21.                     Thread.sleep(500);  
  22.                     return task.taskID;  
  23.                 }  
  24.   
  25.             }  
  26.             .setOnFinishListen(new OnFinishListen() {  
  27.   
  28.                 @Override  
  29.                 public void onFinish(Task task, Object data) {  
  30.                     // TODO Auto-generated method stub  
  31.                     System.err.println("任务编号"+task.taskID+"任务完成");  
  32.                 }  
  33.             })  
  34.             .setTaskID(i)  
  35.             .start();  
  36.         }  
  37.     }  
  38.   
  39. }  



 

 

 

[java] view plaincopyprint?
 
  1. package demo2;  
  2.   
  3. import java.util.HashMap;  
  4.   
  5. import java.util.Map;  
  6. import java.util.Observable;  
  7. import java.util.Observer;  
  8.   
  9. public abstract class Task<P,R> implements Runnable, Observer,TaskAction<P,R>{  
  10.   
  11.       
  12.   
  13.       
  14.     //设置最大任务数  
  15.     public static void setThreadMaxNum(int num) {  
  16.         TaskQueue.ThreadMaxNum = num<1?1:num>100?100:num;  
  17.     }  
  18.   
  19.       
  20.       
  21.     public static enum TaskPriority {  
  22.         max, min;  
  23.     }  
  24.   
  25.     /** 单例 可以提高性能 */  
  26.     protected final static Exception withoutException = new Exception(  
  27.             "The state is without");  
  28.   
  29.     // 名字映射  
  30.     private static HashMap<String, Task> nameTasks;  
  31.   
  32.     public static HashMap<String, Task> getNameTask() {  
  33.         if (nameTasks == null) {  
  34.             nameTasks = new HashMap<String, Task>();  
  35.         }  
  36.         return nameTasks;  
  37.   
  38.     }  
  39.   
  40.     public Task<P,R> setSingletonName(String singletonName) {  
  41.         this.singletonName = singletonName;  
  42.         return this;  
  43.     }  
  44.   
  45.     public String getSingletonName() {  
  46.         return singletonName;  
  47.     }  
  48.   
  49.     public interface OnStartListen {  
  50.         void onStart(Task t);  
  51.     }  
  52.   
  53.     public interface OnProgressListen {  
  54.         void onProgress(Task task, int progress, Object data);  
  55.     }  
  56.   
  57.     public static interface OnFinishListen<P,R> {  
  58.         void onFinish(Task<P,R> task, R data);  
  59.     }  
  60.   
  61.     public interface OnSystemStartListen {  
  62.         void onSystemStart(Task task);  
  63.     }  
  64.   
  65.     public interface OnSystemFinishListen {  
  66.         void OnSystemFinish(Task t, Object data);  
  67.     }  
  68.   
  69.       
  70.   
  71.     /** 请求参数 */  
  72.     protected P parameter;  
  73.     /** 任务开始监听 */  
  74.     protected OnStartListen onStartListen;  
  75.     /** 任务进度监听 */  
  76.     protected OnProgressListen onProgressListen;  
  77.     /** 任务完成监听 */  
  78.     protected OnFinishListen<P,R> onFinishListen;  
  79.     /** 任务在队列中完成 监听 */  
  80.     protected OnSystemStartListen onSystemStartListen;  
  81.     /** 任务在队列中开始 监听 */  
  82.     protected OnSystemFinishListen onSystemFinishListen;  
  83.     /** 用于任务完成后发送消息 */  
  84.     /** 结果 */  
  85.     protected R result;  
  86.     /** 任务编号标示 */  
  87.     protected int taskID = -1;  
  88.     /** 任务名字标示 */  
  89.     /** 设置此任务名是否为单例，单例模式下，如果相同名字的任务未执行完，则无法添加新任务 */  
  90.     protected String singletonName;  
  91.   
  92.     /** 保存一个对象 */  
  93.     protected Object tag;  
  94.     /** 获得当前自身线程的引用 在threadRun方法 */  
  95.     protected Thread thread;  
  96.     /** 重连次数 */  
  97.     protected int tryAgainCount = 1;  
  98.     /** 重连间隔 */  
  99.     protected int tryAgainTime = 1000;  
  100.   
  101.   
  102.   
  103.     /** 默认优先级低 */  
  104.     protected TaskPriority priority = TaskPriority.min;  
  105.   
  106.   
  107.     protected HashMap<String,Object> dataMap;  
  108.       
  109.   
  110.     protected Task() {  
  111.     }  
  112.   
  113.   
  114.   
  115.     // 任务状态  
  116.     public static enum TaskStatus {  
  117.         // 未处理 出错 完成 执行中 排除  
  118.         untreated, wait,error, finsh, running, without;  
  119.     }  
  120.   
  121.     /** 状态 */  
  122.     TaskStatus status = TaskStatus.untreated;  
  123.   
  124.     public void setWithout() {  
  125.         this.status = TaskStatus.without;  
  126.     }  
  127.   
  128.     public void remove() {  
  129.         this.status = TaskStatus.without;  
  130.     }  
  131.   
  132.     public TaskPriority getPriority() {  
  133.         return priority;  
  134.     }  
  135.   
  136.     public void setPriority(TaskPriority priority) {  
  137.         this.priority = priority;  
  138.     }  
  139.   
  140.   
  141.       
  142.     /** 启动线程 */  
  143.     public void start() {  
  144.         if (this.priority == null)  
  145.             this.priority = TaskPriority.min;  
  146.           
  147.         synchronized (TaskQueue.tasks_wait) {  
  148.             if (getSingletonName() != null  
  149.                     && Task.getNameTask().get(this.getSingletonName()) != null) {  
  150.                 this.setWithout();  
  151.             } else {  
  152.                 Task.getNameTask().put(this.getSingletonName(), this);  
  153.   
  154.             }  
  155.   
  156.             switch (priority) {  
  157.             case min:  
  158.                 TaskQueue.tasks_wait.remove(this);  
  159.                 TaskQueue.tasks_wait.add(this);  
  160.                 break;  
  161.             case max:  
  162.                 TaskQueue.tasks_wait.remove(this);  
  163.                 TaskQueue.tasks_wait.addFirst(this);  
  164.                 break;  
  165.             default:  
  166.                 break;  
  167.             }  
  168.             // 启动此服务  
  169.             TaskQueue.serivesRun();  
  170.         }  
  171.           
  172.     }  
  173.   
  174.     /** 启动线程 */  
  175.     public void start(TaskPriority priority) {  
  176.           
  177.           
  178.         this.priority = priority;  
  179.         status=TaskStatus.wait;  
  180.         start();  
  181.     }  
  182.   
  183.   
  184.     /** 启动线程 */  
  185.     final void threadRun() {  
  186.         thread = new Thread(this);  
  187.         thread.start();  
  188.     }  
  189.   
  190.     // 中断Execute方法  
  191.     public  void shutDownExecute(){};  
  192.   
  193.     public  R cacheData(P parameter){  
  194.         return result;};  
  195.   
  196.     // 禁止被重写  
  197.     public final Object Execute() throws Exception {  
  198.         // TODO Auto-generated method stub  
  199.         if (onStartListen != null)  
  200.             onStartListen.onStart(this);  
  201.   
  202.         // 队列中回调  
  203.         if (onSystemStartListen != null)  
  204.             onSystemStartListen.onSystemStart(this);  
  205.         // 状态从未处理改变为处理中  
  206.         status = TaskStatus.running;  
  207.   
  208.         // 获取最后一次是否错误  
  209.         Exception exception = null;  
  210.         // 是否有缓存数据如果没有  
  211.         if ((result = cacheData(parameter)) == null) {  
  212.   
  213.             // 失败重联次数  
  214.             for (int i = 0; i < tryAgainCount; i++) {  
  215.                 try {  
  216.                     // 如果状态改变为排除则跳出失败重联  
  217.                     if (status == TaskStatus.without) {  
  218.                         break;  
  219.                     }  
  220.                     exception = null;  
  221.                     result = obtainData(this, parameter);  
  222.                     System.out.println("result=" + result);  
  223.                     break;  
  224.                 } catch (Exception e) {  
  225.                     // TODO Auto-generated catch block  
  226.                     if ((exception = e) == withoutException) {  
  227.                         break;  
  228.                     }  
  229.                     e.printStackTrace();  
  230.                     try {  
  231.                         Thread.sleep(tryAgainTime);  
  232.                     } catch (Exception e1) {  
  233.                         // TODO Auto-generated catch block  
  234.                         e1.printStackTrace();  
  235.                     }  
  236.                 }  
  237.             }  
  238.         }  
  239.         // 如果最后一次仍然失败则抛出  
  240.         if (exception != null) {  
  241.             throw exception;  
  242.         }  
  243.   
  244.   
  245.         // 如果状态改变为处理完但不通知  
  246.         if (status != TaskStatus.without) {  
  247.   
  248.             if (onFinishListen != null) {  
  249.                 //完成监听并将结果加入到主线程  
  250.                 onFinishListen.onFinish(this, result);  
  251.             }  
  252.             ;  
  253.   
  254.   
  255.         }  
  256.         if (onSystemFinishListen != null) {  
  257.             onSystemFinishListen.OnSystemFinish(this, result);  
  258.         }  
  259.         status = TaskStatus.finsh;  
  260.         return result;  
  261.     }  
  262.   
  263.     public abstract  R obtainData(Task<P,R> task, P parameter)throws Exception;  
  264.   
  265.     @Override  
  266.     public void update(Observable observable, Object data) {  
  267.         // 移除观察  
  268.         observable.deleteObserver(this);  
  269.         // 中断 停止关闭连接  
  270.         this.shutDownExecute();  
  271.         this.setWithout();  
  272.         if (this.thread != null) {  
  273.             this.thread.interrupt();  
  274.         }  
  275.         // 错误尝试次数为0  
  276.         this.tryAgainCount = 0;  
  277.     };  
  278.   
  279.     @Override  
  280.     public void run() {  
  281.   
  282.         try {  
  283.             Execute();  
  284.         } catch (Exception e) {  
  285.             e.printStackTrace();  
  286.             status = TaskStatus.error;  
  287.   
  288.   
  289.               
  290.             // 如果状态改变为处理完但不通知  
  291.             if (status != TaskStatus.without) {  
  292.                   
  293.                 if (onFinishListen != null) {  
  294.                     //将结果加入到主线程  
  295.                     onFinishListen.onFinish(this, result);  
  296.                 }  
  297.   
  298.             }  
  299.             if (onSystemFinishListen != null) {  
  300.                 onSystemFinishListen.OnSystemFinish(this, e);  
  301.             }  
  302.         }  
  303.   
  304.         //递归 避免新开线程   唤醒等待中的任务   
  305.         TaskQueue.getRunnable().notifyWaitingTask();  
  306.           
  307.     }  
  308.   
  309.   
  310.   
  311.     public Object getTag() {  
  312.         return tag;  
  313.     }  
  314.   
  315.     public Task setTag(Object tag) {  
  316.         this.tag = tag;  
  317.         return this;  
  318.     }  
  319.   
  320.     public Thread getThread() {  
  321.         return thread;  
  322.     }  
  323.   
  324.     public TaskStatus getStatus() {  
  325.         return status;  
  326.     }  
  327.   
  328.     public Object getParameter() {  
  329.         return parameter;  
  330.     }  
  331.   
  332.     public Task setParameter(P parameter) {  
  333.         this.parameter = parameter;  
  334.         return this;  
  335.     }  
  336.   
  337.     public OnStartListen getOnStartListen() {  
  338.         return onStartListen;  
  339.     }  
  340.   
  341.     public Task setOnStartListen(OnStartListen onStartListen) {  
  342.         this.onStartListen = onStartListen;  
  343.         return this;  
  344.     }  
  345.   
  346.     public OnProgressListen getOnProgressListen() {  
  347.         return onProgressListen;  
  348.     }  
  349.   
  350.     public Task setOnProgressListen(OnProgressListen onProgressListen) {  
  351.         this.onProgressListen = onProgressListen;  
  352.         return this;  
  353.     }  
  354.   
  355.     public OnFinishListen getOnFinishListen() {  
  356.         return onFinishListen;  
  357.     }  
  358.   
  359.     public Task setOnFinishListen(OnFinishListen onFinishListen) {  
  360.         this.onFinishListen = onFinishListen;  
  361.         return this;  
  362.     }  
  363.   
  364.     public OnSystemStartListen getOnSystemStartListen() {  
  365.         return onSystemStartListen;  
  366.     }  
  367.   
  368.     public OnSystemFinishListen getOnSystemFinishListen() {  
  369.         return onSystemFinishListen;  
  370.     }  
  371.   
  372.     public void setOnSystemFinishListen(  
  373.             OnSystemFinishListen onSystemFinishListen) {  
  374.         this.onSystemFinishListen = onSystemFinishListen;  
  375.     }  
  376.   
  377.   
  378.     public int getTaskID() {  
  379.         return taskID;  
  380.     }  
  381.   
  382.     public Task setTaskID(int taskID) {  
  383.         this.taskID = taskID;  
  384.         return this;  
  385.     }  
  386.   
  387.     public Object getResult() {  
  388.         return result;  
  389.     }  
  390.   
  391.     public int getTryAgainCount() {  
  392.         return tryAgainCount;  
  393.     }  
  394.   
  395.     public Task setTryAgainCount(int tryAgainCount) {  
  396.         this.tryAgainCount = tryAgainCount;  
  397.         return this;  
  398.     }  
  399.   
  400.     public int getTryAgainTime() {  
  401.         return tryAgainTime;  
  402.     }  
  403.   
  404.     private Task setTryAgainTime(int tryAgainTime) {  
  405.         this.tryAgainTime = tryAgainTime;  
  406.         return this;  
  407.     }  
  408.   
  409.       
  410.   
  411.     public Object  put(String key,Object value) {  
  412.         if(dataMap==null)  
  413.         {  
  414.             dataMap=new HashMap<String, Object>();  
  415.         }  
  416.         return dataMap.put(key, value);  
  417.     }  
  418.     public Object  get(String key,Object value) {  
  419.         if(dataMap==null)  
  420.         {  
  421.             dataMap=new HashMap<String, Object>();  
  422.         }  
  423.         return dataMap.get(key);  
  424.     }  
  425.   
  426.       
  427.     
  428. }  

 

[java] view plaincopyprint?
 
  1. package demo2;  
  2.   
  3. import java.util.AbstractCollection;  
  4. import java.util.ArrayList;  
  5. import java.util.Collections;  
  6. import java.util.Iterator;  
  7. import java.util.LinkedList;  
  8. import java.util.List;  
  9. import java.util.Queue;  
  10. import java.util.Random;  
  11.   
  12. import demo2.Task.OnSystemFinishListen;  
  13. import demo2.Task.TaskStatus;  
  14.   
  15.   
  16. public class TaskQueue implements Runnable, OnSystemFinishListen {  
  17.     static String debug = "TaskQueue";  
  18.     @SuppressWarnings("unchecked")  
  19.     // 在等待的任务队列  
  20.      static LinkedList<Task> tasks_wait = new LinkedList<Task>();  
  21.   
  22.     public static class TaskQueueExpection extends Exception{  
  23.         TaskQueueExpection(String detailMessage) {  
  24.             super(detailMessage);  
  25.             // TODO Auto-generated constructor stub  
  26.         }  
  27.           
  28.     };  
  29.       
  30.     // 正在执行的任务  
  31.      static ArrayList<Task> tasks_running = new ArrayList<Task>();  
  32.     // 是否持续运行  
  33.     public static boolean isRun=true;  
  34.     // runnable保证线程安全  
  35.     private static TaskQueue runnable = new TaskQueue();;  
  36.     // 最大线程数  
  37.     static int ThreadMaxNum = 1;  
  38.   
  39.     public static TaskQueue getRunnable() {  
  40.         return runnable;  
  41.     }  
  42.   
  43.     // 如果队列线程为空或者停止则重新开启  
  44.     public static void serivesRun() {  
  45.         // TODO Auto-generated method stub  
  46.         boolean isCanSeriver=false;  
  47.         synchronized (tasks_running) {  
  48.             isCanSeriver=tasks_running.size() < ThreadMaxNum;  
  49.         }  
  50.        runnable.run();  
  51.     }  
  52.       
  53.     //获取正在执行的任务数  
  54.     public static int getRunningTaskCount() {  
  55.         synchronized (TaskQueue.tasks_running) {  
  56.             return TaskQueue.tasks_running.size();  
  57.         }  
  58.     }  
  59.     //设置最大任务数  
  60.     public static void setThreadMaxNum(int num) {  
  61.         TaskQueue.ThreadMaxNum = num<1?1:num>100?100:num;  
  62.     }  
  63.   
  64.     // 线程锁 如果等待队列的任务数不为空，并且当前线程数字少于最大线程数  
  65.     public static boolean taskRun() {  
  66.         synchronized (tasks_wait) {  
  67.             synchronized (tasks_running) {  
  68.                 return !tasks_wait.isEmpty()  
  69.                         && tasks_running.size() < ThreadMaxNum;  
  70.             }  
  71.         }  
  72.     }  
  73.     //开启新线程  
  74.     public void run() {  
  75.         // 线程锁 如果等待队列的任务数不为空，并且当前线程数字少于最大线程数  
  76.         Task newTask;  
  77.         while((newTask=getWaittingTask())!=null)  
  78.         {  
  79.             System.err.println("开启新线程处理一个新任务，ID："+newTask.getTaskID());  
  80.             newTask.setOnSystemFinishListen(runnable);  
  81.             newTask.threadRun();  
  82.             newTask=null;  
  83.         }  
  84.          
  85.     }  
  86.       
  87.      //递归 避免新开线程   唤醒等待中的任务 但此方案会造成java.lang.StackOverflowError  
  88.      void notifyWaitingTask()  
  89.     {  
  90.         Task newTask;  
  91.         while((newTask=getWaittingTask())!=null)  
  92.         {  
  93.             System.err.println("唤醒旧线程处理一个新任务，ID："+newTask.getTaskID());  
  94.             newTask.setOnSystemFinishListen(runnable);  
  95.             newTask.run();  
  96.             newTask=null;  
  97.         }  
  98.           
  99.     }  
  100.       
  101.     private  Task getWaittingTask()  
  102.     {  
  103.         Task t=null;  
  104.         //测试  
  105.         while (isRun && taskRun()) {  
  106.             // 添加带执行中动态数组中  
  107.             synchronized (tasks_wait) {  
  108.                 // 从等待任务的队列中获取并移除此列表的头（第一个元素）  
  109.                 t = tasks_wait.poll();  
  110.                 // 如果h为空则从队列重新取对象或者任务绑定的状态变化了  
  111.                 if (t == null || t.status == TaskStatus.without) {  
  112.                     System.out.println("任务取消 编号" + t!=null?String.valueOf(t.getTaskID()):"空任务");  
  113.                     continue;  
  114.                 }  
  115.             }  
  116.             synchronized (tasks_running) {  
  117.                 tasks_running.add(t);  
  118.             }  
  119.             System.out.println( "正在执行任务数" + tasks_running.size() + "/上限"  
  120.                     + ThreadMaxNum);  
  121.   
  122.             return t;  
  123.         }  
  124.         return t;  
  125.     }  
  126.       
  127.   
  128.     @Override  
  129.     public void OnSystemFinish(Task t, Object data) {  
  130.         // TODO Auto-generated method stub  
  131.         synchronized (tasks_running) {  
  132.             // 从处理中的动态数组中移除此任务  
  133.             tasks_running.remove(t);  
  134.             System.out.println( "执行队列中移除任务taskid=" + t.taskID);  
  135.             // 通知执行后续未处理的任务  
  136.             System.out.println("正在执行任务数" + tasks_running.size() + "/上限"  
  137.                     + ThreadMaxNum);  
  138.              
  139.             // 移除此名字映射  
  140.             if (t.getSingletonName() != null) {  
  141.                 Task.getNameTask().remove(t.getSingletonName());  
  142.             }  
  143.         }  
  144.           
  145.   
  146.     }  
  147.   
  148. }  


Demo代码下载地址

 

 

版权声明：本文为博主原创文章，未经博主允许不得转载。

Java Design Demo -简单的队列-异步多任务队列（java android）

标签：

原文地址：http://www.cnblogs.com/Free-Thinker/p/4821404.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！