Java多线程处理任务（摘抄）

 

很多时候，我们需要对一个庞大的队列或者二维数组进行处理。这些处理可能是循环的，比如给一个excel多个sheet的联系人列表发邮件。很幼稚的方法就是用一个或者两个FOR循环搞定，对于庞大的数据有得让你等的。最要命的是当你出去喝茶的时候，程序没有处理好抛出Exception了，那你原本的计划任务都会终止。

多线程的好处是比较多的，特别是能装装B，让你从男孩变成男人的感觉。不废话了，我简化了工作中使用的一个多线程框架，做了些扩展，直接上代码：

 

 

1：多线程处理线性队列 

 

1. public static void processLineTask(final List<Object> list, int threadCount){  
2.     //确保线程数量不大于队列长度  
3.     threadCount = Math.min(threadCount, list.size());  
4.   
5.     for(int i = 0;i < threadCount;i++){  
6.         new Thread(){  
7.             public void run(){  
8.                 while(true){  
9.                     Object o;  
10.   
11.                     //提取队列元素的时候，需要锁住队列  
12.                     synchronized(list){  
13.                         //当队列长度为0的时候，线程逐个结束  
14.                         if(list.size() == 0){  
15.                             break;  
16.                         }  
17.                         o = list.remove(0);  
18.                     }  
19.                     //这里可以写一些对元素o的操作  
20.                     //……  
21.                 }  
22.             }  
23.         }.start();  
24.     }          
25. }  

 

 

 

2：多线程处理环状队列

 

1. public static void processCircleTask(final List<Object> list, int threadCount){  
2.     //确保线程数量不大于队列长度  
3.     threadCount = Math.min(threadCount, list.size());  
4.   
5.     for(int i = 0;i < threadCount;i++){  
6.         new Thread(){  
7.             public void run(){  
8.                 while(true){  
9.                     Object o;  
10.   
11.                     //提取队列元素的时候，需要锁住队列  
12.                     synchronized(list){  
13.                         o = list.remove(0);  
14.                     }  
15.                     //这里可以写一些对元素o的操作  
16.                     //……  
17.   
18.                     //为防止小环导致循环过快，可以给每个o添加时间属性，如果间隔过小就在此sleep  
19.   
20.   
21.                     //把元素放到队列尾部  
22.                     synchronized(list){  
23.                         list.add(o);  
24.                     }  
25.                 }  
26.             }  
27.         }.start();  
28.     }  
29. }  

 

 

 

3：多线程处理二维数组，单线处理

1. public static void processMultiListTask1(final List<List<Object>> list, int threadCount){  
2.     //确保线程数量不大于队列长度  
3.     threadCount = Math.min(threadCount, list.size());  
4.   
5.     for(int i = 0;i < threadCount;i++){  
6.         new Thread(){  
7.             public void run(){  
8.                 while(true){  
9.                     List<Object> listSub;  
10.   
11.                     //提取值，需要锁住对象  
12.                     synchronized(list){  
13.                         if(list.size() == 0){  
14.                             break;  
15.                         }                              
16.                         listSub = list.remove(0);  
17.                     }  
18.   
19.                     Object o;  
20.                     for(int i = 0;i < listSub.size();i++){  
21.                         o = listSub.get(i);  
22.                         //这里可以写一些对元素o的操作  
23.                         //……  
24.                     }  
25.                 }  
26.             }  
27.         }.start();  
28.     }  
29. }  

 

 

 

4：多线程处理二维数组，交叉处理

 

 

1. public static void processMultiListTask2(final List<List<Object>> list, int threadCount){  
2.     //确保线程数量不大于队列长度  
3.     threadCount = Math.min(threadCount, list.size());  
4.   
5.     for(int i = 0;i < threadCount;i++){  
6.         new Thread(){  
7.             public void run(){  
8.                 while(true){  
9.                     Object o;  
10.   
11.                     //提取值，需要锁住对象  
12.                     synchronized(list){  
13.                         if(list.size() == 0){  
14.                             break;  
15.                         }  
16.                         if(list.get(0).size() == 0){  
17.                             list.remove(0);  
18.                         }  
19.   
20.                         o = list.get(0).remove(0);  
21.                     }  
22.                     //这里可以写一些对元素o的操作  
23.                     //……  
24.                 }  
25.             }  
26.         }.start();  
27.     }  
28. }