Java多线程处理任务(摘抄)

时间:2022-06-17 23:19:34

 

很多时候,我们需要对一个庞大的队列或者二维数组进行处理。这些处理可能是循环的,比如给一个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. }