【T】并行调度

/** 
         * 并行调度相关处理 
         *  
         * 按卫星*日期 ，将待处理的任务分解为 卫星+日期 粒度的子任务 添加到paramMapList列表中 
         */  
        List<Map<String, Object>> paramMapList = new ArrayList<Map<String, Object>>();  
        for (Iterator<OrderParamSatellite> iterator = paramSatellites.iterator(); iterator.hasNext();) {  
            OrderParamSatellite paramSatellite = iterator.next();  
              
            paramMapList.addAll(this.getParamMapList(paramSatellite));  
        }  
  
  
  
        //根据集群最大处理能力,分页处理任务列表，作为list截取的步长  
          
        int fsize = HostServerQueue.getInstance().freeSize();  
        for(int i=0;i<paramMapList.size();i=i+fsize){  
            List<Map<String, Object>> tl = BXexample.getSubListPage(paramMapList, i,  fsize);  
            //并行调度  
            BXexample.BXfunction(tl,new ExectueCallBack(){  
                    public void doExectue(Object executor) throws Exception {  
                        ExecuteOrderBTask((Map<String, Object>)executor);  
                    }  
            });  
              
            //动态查找空闲节点数量，即集群最大处理能力  
            fsize = HostServerQueue.getInstance().freeSize();  
        } 

 

package com.zlg.cobarclient;

import java.util.ArrayList;  
import java.util.Collection;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Map;  
import java.util.concurrent.BlockingQueue;  
import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.LinkedBlockingQueue;  
import java.util.concurrent.ThreadFactory;  
import java.util.concurrent.ThreadPoolExecutor;  
import java.util.concurrent.TimeUnit;  
  
import org.apache.commons.lang.exception.ExceptionUtils;  
import org.springframework.dao.ConcurrencyFailureException;  

public class BXexample {
    private static ExecutorService createCustomExecutorService(int poolSize, final String method) {  
        int coreSize = Runtime.getRuntime().availableProcessors();//返回系统CUP数量  
        if (poolSize < coreSize) {  
            coreSize = poolSize;  
        }  
        ThreadFactory tf = new ThreadFactory() {  
            public Thread newThread(Runnable r) {  
                Thread t = new Thread(r, "thread created at BXexample method [" + method + "]");  
                t.setDaemon(true);  
                return t;  
            }  
        };  
        BlockingQueue<Runnable> queueToUse = new LinkedBlockingQueue<Runnable>();  
        final ThreadPoolExecutor executor = new ThreadPoolExecutor(coreSize, poolSize, 60,  
                TimeUnit.SECONDS, queueToUse, tf, new ThreadPoolExecutor.CallerRunsPolicy());  

        return executor;  
 }  

public static <T> List<T> getSubListPage(List<T> list, int skip,int pageSize) {  
    if (list == null || list.isEmpty()) {  
        return null;  
    }  
    int startIndex = skip;  
    int endIndex = skip + pageSize;  
    if (startIndex > endIndex || startIndex > list.size()) {  
        return null;  
    }  
    if (endIndex > list.size()) {  
        endIndex = list.size();  
    }  
    return list.subList(startIndex, endIndex);  
}  
  
  
public static void BXfunction(Collection<?> paramCollection,final ExectueCallBack ecb){  
    //构建执行器  
    ExecutorService executor = createCustomExecutorService(Runtime.getRuntime().availableProcessors(), "batchExecuteProjection");  
    try {  
        //监视器  
        final CountDownLatch latch = new CountDownLatch(paramCollection.size());  
        final StringBuffer exceptionStaktrace = new StringBuffer();  
        Iterator<?> iter = paramCollection.iterator();  
        while (iter.hasNext()) {  
            final Object entity = iter.next();  
            Runnable task = new Runnable() {  
                public void run() {  
                    try {  
                        ecb.doExectue(entity);  
                    } catch (Throwable t) {  
                        exceptionStaktrace.append(ExceptionUtils.getFullStackTrace(t));  
                    } finally {  
                        latch.countDown();  
                    }  
                }  
            };  
            executor.execute(task);//并行调度  
        }  

        try {  
            latch.await();//监视器等待所有线程执行完毕  
        } catch (InterruptedException e) {  
            //调度异常  
            throw new ConcurrencyFailureException(  
                    "unexpected interruption when re-arranging parameter collection into sub-collections ",e);  
        }  
        if (exceptionStaktrace.length() > 0) {  
            //业务异常  
            throw new ConcurrencyFailureException(  
                    "unpected exception when re-arranging parameter collection, check previous log for details.\n"+ exceptionStaktrace);  
        }  
          
          
    } finally {  
        executor.shutdown();//执行器关闭  
    }  
}
}

package com.zlg.cobarclient;

public interface ExectueCallBack {
    void doExectue(Object executor) throws Exception;
}

package com.zlg.cobarclient;

import java.util.ArrayList;
import java.util.List;


public class Hello {
    public static void main(String[] args) {
        List<String> paramCollection  = new ArrayList<String>();  
        paramCollection.add("9");  
        paramCollection.add("2");  
        paramCollection.add("18");  
        paramCollection.add("7");  
        paramCollection.add("6");  
        paramCollection.add("1");  
        paramCollection.add("3");  
        paramCollection.add("4");  
           paramCollection.add("14");  
        paramCollection.add("13");  
          
        int freesize = 3;//当前处理能力  
          
        for(int i=0;i<paramCollection.size();i=i+freesize){  
              
            List<String> tl = BXexample.getSubListPage(paramCollection, i, freesize);  
              
            BXexample.BXfunction(tl,new ExectueCallBack() {  
                public void doExectue(Object executor) throws Exception {  
                    int k = Integer.parseInt((String)executor);  
      
                    for(int i=0;i<k*10000000;i++){  
                        //执行循环  
                    }  
                    System.out.println(k+"：hello world");  
                }  
            });  
        }
    }
}