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

Demo代码下载地址

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

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

单线程的消息队列示例

[java] view plain copy

print?

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. }  

package demo1;import java.util.LinkedList;public class Main {    /**     * @param args     */    private static Thread thread;    private static LinkedList<Runnable> list = new LinkedList<Runnable>();    static int test = 0;    public static void main(String[] args) {        // TODO Auto-generated method stub        final long time = System.currentTimeMillis();        for (int i = 0; i < 20; i++) {            tastEvent(new Runnable() {                public void run() {                        try {                            Thread.sleep(500);                        } catch (InterruptedException e) {                            // TODO Auto-generated catch block                            e.printStackTrace();                        }                        System.out                                .println("第"                                        + (++test)                                        + ("个任务  耗时:" + (System                                                .currentTimeMillis() - time)));                    }            });        }    }    public static void tastEvent(Runnable r) {        synchronized (list) {            list.add(r);        }            if (thread == null) {                thread = new Thread(run);                thread.start();            }    }    static Runnable run = new Runnable() {        @Override        public void run() {            // TODO Auto-generated method stub            synchronized (list) {                while (!list.isEmpty()) {                    // new Thread(list.poll()).start();                    list.poll().run();                }                thread = null;            }        }    };}

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

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

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

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

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

[java] view plain copy

print?

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();  

        final long  timer=System.currentTimeMillis();        count=0;        final Handler h=new Handler();        for(int k=0;k<100;k++){        new Thread(){            @Override            public void run() {                // TODO Auto-generated method stub                try {                    Thread.sleep(10);                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }                h.post(new Runnable() {                    @Override                    public void run() {                        Toast.makeText(getApplicationContext()," 耗时"+ (System.currentTimeMillis() - timer), 1).show();                        System.err.println("编号"+(count++)+"线程消耗了"+(System.currentTimeMillis()-timer));                    }                });            }        }.start();

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

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

[java] view plain copy

print?

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. }  

package demo2;import demo2.Task.OnFinishListen;public class Main {    /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        Task.setThreadMaxNum(3);        for (int i = 0; i < 15; i++) {            new Task() {                @Override                public Object obtainData(Task task, Object parameter)                        throws Exception {                    // TODO Auto-generated method stub                    Thread.sleep(500);                    return task.taskID;                }            }            .setOnFinishListen(new OnFinishListen() {                @Override                public void onFinish(Task task, Object data) {                    // TODO Auto-generated method stub                    System.err.println("任务编号"+task.taskID+"任务完成");                }            })            .setTaskID(i)            .start();        }    }}

[java] view plain copy

print?

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. }  

package demo2;import java.util.HashMap;import java.util.Map;import java.util.Observable;import java.util.Observer;public abstract class Task<P,R> implements Runnable, Observer,TaskAction<P,R>{    //设置最大任务数    public static void setThreadMaxNum(int num) {        TaskQueue.ThreadMaxNum = num<1?1:num>100?100:num;    }    public static enum TaskPriority {        max, min;    }    /** 单例 可以提高性能 */    protected final static Exception withoutException = new Exception(            "The state is without");    // 名字映射    private static HashMap<String, Task> nameTasks;    public static HashMap<String, Task> getNameTask() {        if (nameTasks == null) {            nameTasks = new HashMap<String, Task>();        }        return nameTasks;    }    public Task<P,R> setSingletonName(String singletonName) {        this.singletonName = singletonName;        return this;    }    public String getSingletonName() {        return singletonName;    }    public interface OnStartListen {        void onStart(Task t);    }    public interface OnProgressListen {        void onProgress(Task task, int progress, Object data);    }    public static interface OnFinishListen<P,R> {        void onFinish(Task<P,R> task, R data);    }    public interface OnSystemStartListen {        void onSystemStart(Task task);    }    public interface OnSystemFinishListen {        void OnSystemFinish(Task t, Object data);    }    /** 请求参数 */    protected P parameter;    /** 任务开始监听 */    protected OnStartListen onStartListen;    /** 任务进度监听 */    protected OnProgressListen onProgressListen;    /** 任务完成监听 */    protected OnFinishListen<P,R> onFinishListen;    /** 任务在队列中完成 监听 */    protected OnSystemStartListen onSystemStartListen;    /** 任务在队列中开始 监听 */    protected OnSystemFinishListen onSystemFinishListen;    /** 用于任务完成后发送消息 */    /** 结果 */    protected R result;    /** 任务编号标示 */    protected int taskID = -1;    /** 任务名字标示 */    /** 设置此任务名是否为单例，单例模式下，如果相同名字的任务未执行完，则无法添加新任务 */    protected String singletonName;    /** 保存一个对象 */    protected Object tag;    /** 获得当前自身线程的引用 在threadRun方法 */    protected Thread thread;    /** 重连次数 */    protected int tryAgainCount = 1;    /** 重连间隔 */    protected int tryAgainTime = 1000;    /** 默认优先级低 */    protected TaskPriority priority = TaskPriority.min;    protected HashMap<String,Object> dataMap;    protected Task() {    }    // 任务状态    public static enum TaskStatus {        // 未处理 出错 完成 执行中 排除        untreated, wait,error, finsh, running, without;    }    /** 状态 */    TaskStatus status = TaskStatus.untreated;    public void setWithout() {        this.status = TaskStatus.without;    }    public void remove() {        this.status = TaskStatus.without;    }    public TaskPriority getPriority() {        return priority;    }    public void setPriority(TaskPriority priority) {        this.priority = priority;    }    /** 启动线程 */    public void start() {        if (this.priority == null)            this.priority = TaskPriority.min;        synchronized (TaskQueue.tasks_wait) {            if (getSingletonName() != null                    && Task.getNameTask().get(this.getSingletonName()) != null) {                this.setWithout();            } else {                Task.getNameTask().put(this.getSingletonName(), this);            }            switch (priority) {            case min:                TaskQueue.tasks_wait.remove(this);                TaskQueue.tasks_wait.add(this);                break;            case max:                TaskQueue.tasks_wait.remove(this);                TaskQueue.tasks_wait.addFirst(this);                break;            default:                break;            }            // 启动此服务            TaskQueue.serivesRun();        }    }    /** 启动线程 */    public void start(TaskPriority priority) {        this.priority = priority;        status=TaskStatus.wait;        start();    }    /** 启动线程 */    final void threadRun() {        thread = new Thread(this);        thread.start();    }    // 中断Execute方法    public  void shutDownExecute(){};    public  R cacheData(P parameter){        return result;};    // 禁止被重写    public final Object Execute() throws Exception {        // TODO Auto-generated method stub        if (onStartListen != null)            onStartListen.onStart(this);        // 队列中回调        if (onSystemStartListen != null)            onSystemStartListen.onSystemStart(this);        // 状态从未处理改变为处理中        status = TaskStatus.running;        // 获取最后一次是否错误        Exception exception = null;        // 是否有缓存数据如果没有        if ((result = cacheData(parameter)) == null) {            // 失败重联次数            for (int i = 0; i < tryAgainCount; i++) {                try {                    // 如果状态改变为排除则跳出失败重联                    if (status == TaskStatus.without) {                        break;                    }                    exception = null;                    result = obtainData(this, parameter);                    System.out.println("result=" + result);                    break;                } catch (Exception e) {                    // TODO Auto-generated catch block                    if ((exception = e) == withoutException) {                        break;                    }                    e.printStackTrace();                    try {                        Thread.sleep(tryAgainTime);                    } catch (Exception e1) {                        // TODO Auto-generated catch block                        e1.printStackTrace();                    }                }            }        }        // 如果最后一次仍然失败则抛出        if (exception != null) {            throw exception;        }        // 如果状态改变为处理完但不通知        if (status != TaskStatus.without) {            if (onFinishListen != null) {                //完成监听并将结果加入到主线程                onFinishListen.onFinish(this, result);            }            ;        }        if (onSystemFinishListen != null) {            onSystemFinishListen.OnSystemFinish(this, result);        }        status = TaskStatus.finsh;        return result;    }    public abstract  R obtainData(Task<P,R> task, P parameter)throws Exception;    @Override    public void update(Observable observable, Object data) {        // 移除观察        observable.deleteObserver(this);        // 中断 停止关闭连接        this.shutDownExecute();        this.setWithout();        if (this.thread != null) {            this.thread.interrupt();        }        // 错误尝试次数为0        this.tryAgainCount = 0;    };    @Override    public void run() {        try {            Execute();        } catch (Exception e) {            e.printStackTrace();            status = TaskStatus.error;            // 如果状态改变为处理完但不通知            if (status != TaskStatus.without) {                if (onFinishListen != null) {                    //将结果加入到主线程                    onFinishListen.onFinish(this, result);                }            }            if (onSystemFinishListen != null) {                onSystemFinishListen.OnSystemFinish(this, e);            }        }        //递归 避免新开线程   唤醒等待中的任务         TaskQueue.getRunnable().notifyWaitingTask();    }    public Object getTag() {        return tag;    }    public Task setTag(Object tag) {        this.tag = tag;        return this;    }    public Thread getThread() {        return thread;    }    public TaskStatus getStatus() {        return status;    }    public Object getParameter() {        return parameter;    }    public Task setParameter(P parameter) {        this.parameter = parameter;        return this;    }    public OnStartListen getOnStartListen() {        return onStartListen;    }    public Task setOnStartListen(OnStartListen onStartListen) {        this.onStartListen = onStartListen;        return this;    }    public OnProgressListen getOnProgressListen() {        return onProgressListen;    }    public Task setOnProgressListen(OnProgressListen onProgressListen) {        this.onProgressListen = onProgressListen;        return this;    }    public OnFinishListen getOnFinishListen() {        return onFinishListen;    }    public Task setOnFinishListen(OnFinishListen onFinishListen) {        this.onFinishListen = onFinishListen;        return this;    }    public OnSystemStartListen getOnSystemStartListen() {        return onSystemStartListen;    }    public OnSystemFinishListen getOnSystemFinishListen() {        return onSystemFinishListen;    }    public void setOnSystemFinishListen(            OnSystemFinishListen onSystemFinishListen) {        this.onSystemFinishListen = onSystemFinishListen;    }    public int getTaskID() {        return taskID;    }    public Task setTaskID(int taskID) {        this.taskID = taskID;        return this;    }    public Object getResult() {        return result;    }    public int getTryAgainCount() {        return tryAgainCount;    }    public Task setTryAgainCount(int tryAgainCount) {        this.tryAgainCount = tryAgainCount;        return this;    }    public int getTryAgainTime() {        return tryAgainTime;    }    private Task setTryAgainTime(int tryAgainTime) {        this.tryAgainTime = tryAgainTime;        return this;    }    public Object  put(String key,Object value) {        if(dataMap==null)        {            dataMap=new HashMap<String, Object>();        }        return dataMap.put(key, value);    }    public Object  get(String key,Object value) {        if(dataMap==null)        {            dataMap=new HashMap<String, Object>();        }        return dataMap.get(key);    }}

[java] view plain copy

print?

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. }  

package demo2;import java.util.AbstractCollection;import java.util.ArrayList;import java.util.Collections;import java.util.Iterator;import java.util.LinkedList;import java.util.List;import java.util.Queue;import java.util.Random;import demo2.Task.OnSystemFinishListen;import demo2.Task.TaskStatus;public class TaskQueue implements Runnable, OnSystemFinishListen {    static String debug = "TaskQueue";    @SuppressWarnings("unchecked")    // 在等待的任务队列     static LinkedList<Task> tasks_wait = new LinkedList<Task>();    public static class TaskQueueExpection extends Exception{        TaskQueueExpection(String detailMessage) {            super(detailMessage);            // TODO Auto-generated constructor stub        }    };    // 正在执行的任务     static ArrayList<Task> tasks_running = new ArrayList<Task>();    // 是否持续运行    public static boolean isRun=true;    // runnable保证线程安全    private static TaskQueue runnable = new TaskQueue();;    // 最大线程数    static int ThreadMaxNum = 1;    public static TaskQueue getRunnable() {        return runnable;    }    // 如果队列线程为空或者停止则重新开启    public static void serivesRun() {        // TODO Auto-generated method stub        boolean isCanSeriver=false;        synchronized (tasks_running) {            isCanSeriver=tasks_running.size() < ThreadMaxNum;        }       runnable.run();    }    //获取正在执行的任务数    public static int getRunningTaskCount() {        synchronized (TaskQueue.tasks_running) {            return TaskQueue.tasks_running.size();        }    }    //设置最大任务数    public static void setThreadMaxNum(int num) {        TaskQueue.ThreadMaxNum = num<1?1:num>100?100:num;    }    // 线程锁 如果等待队列的任务数不为空，并且当前线程数字少于最大线程数    public static boolean taskRun() {        synchronized (tasks_wait) {            synchronized (tasks_running) {                return !tasks_wait.isEmpty()                        && tasks_running.size() < ThreadMaxNum;            }        }    }    //开启新线程    public void run() {        // 线程锁 如果等待队列的任务数不为空，并且当前线程数字少于最大线程数        Task newTask;        while((newTask=getWaittingTask())!=null)        {            System.err.println("开启新线程处理一个新任务，ID："+newTask.getTaskID());            newTask.setOnSystemFinishListen(runnable);            newTask.threadRun();            newTask=null;        }    }     //递归 避免新开线程   唤醒等待中的任务 但此方案会造成java.lang.StackOverflowError     void notifyWaitingTask()    {        Task newTask;        while((newTask=getWaittingTask())!=null)        {            System.err.println("唤醒旧线程处理一个新任务，ID："+newTask.getTaskID());            newTask.setOnSystemFinishListen(runnable);            newTask.run();            newTask=null;        }    }    private  Task getWaittingTask()    {        Task t=null;        //测试        while (isRun && taskRun()) {            // 添加带执行中动态数组中            synchronized (tasks_wait) {                // 从等待任务的队列中获取并移除此列表的头（第一个元素）                t = tasks_wait.poll();                // 如果h为空则从队列重新取对象或者任务绑定的状态变化了                if (t == null || t.status == TaskStatus.without) {                    System.out.println("任务取消 编号" + t!=null?String.valueOf(t.getTaskID()):"空任务");                    continue;                }            }            synchronized (tasks_running) {                tasks_running.add(t);            }            System.out.println( "正在执行任务数" + tasks_running.size() + "/上限"                    + ThreadMaxNum);            return t;        }        return t;    }    @Override    public void OnSystemFinish(Task t, Object data) {        // TODO Auto-generated method stub        synchronized (tasks_running) {            // 从处理中的动态数组中移除此任务            tasks_running.remove(t);            System.out.println( "执行队列中移除任务taskid=" + t.taskID);            // 通知执行后续未处理的任务            System.out.println("正在执行任务数" + tasks_running.size() + "/上限"                    + ThreadMaxNum);            // 移除此名字映射            if (t.getSingletonName() != null) {                Task.getNameTask().remove(t.getSingletonName());            }        }    }}

Demo代码下载地址