多线程

package com.pingan.insurance.roadassistant.ruleengine;

import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.RejectedExecutionHandler;  
import java.util.concurrent.ThreadFactory;  
import java.util.concurrent.ThreadPoolExecutor;  
import java.util.concurrent.TimeUnit;  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class CustomThreadPoolExecutor {    
        
        
    private ThreadPoolExecutor pool = null;    
        
        
    /**  
     * 线程池初始化方法  
     *   
     * corePoolSize 核心线程池大小----10  
     * maximumPoolSize 最大线程池大小----100 
     * keepAliveTime 线程池中超过corePoolSize数目的空闲线程最大存活时间----60+单位TimeUnit  
     * TimeUnit keepAliveTime时间单位----TimeUnit.SECONDS  
     * workQueue 阻塞队列----new ArrayBlockingQueue<Runnable>(50)====50容量的阻塞队列  
     * threadFactory 新建线程工厂----new CustomThreadFactory()====定制的线程工厂  
     * rejectedExecutionHandler 当提交任务数超过maxmumPoolSize+workQueue之和时,  
     *                          即当提交第151个任务时(前面线程都没有执行完,此测试方法中用sleep(100)),  
     *                                任务会交给RejectedExecutionHandler来处理  
     */    
    public void init() {    
        pool = new ThreadPoolExecutor(
                10,    
                100,    
                60,    
                TimeUnit.SECONDS,    
                new ArrayBlockingQueue<Runnable>(50),    
                new CustomThreadFactory(),    
                new CustomRejectedExecutionHandler());    
    }    
    
        
    public void destory() {    
        if(pool != null) {    
            pool.shutdownNow();    
        }    
    }    
        
    public CustomThreadPoolExecutor(){
    	init();
    }
    
    
    public ExecutorService getCustomThreadPoolExecutor() {    
        return this.pool;    
    }    
        
    private class CustomThreadFactory implements ThreadFactory {    
    
        private AtomicInteger count = new AtomicInteger(0);    
            
        @Override    
        public Thread newThread(Runnable r) {    
            Thread t = new Thread(r);    
            String threadName = CustomThreadPoolExecutor.class.getSimpleName() + count.addAndGet(1);    
            System.out.println(threadName);    
            t.setName(threadName);    
            return t;    
        }    
    }    
        
        
    private class CustomRejectedExecutionHandler implements RejectedExecutionHandler {    
    
        @Override    
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {    
            try {  
                // 核心改造点，由blockingqueue的offer改成put阻塞方法
                executor.getQueue().put(r);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }    
    }    
    
}

public class AllotTask implements Runnable {

		OrderInfo orderInfo;
		
		AllotTask(OrderInfo orderInfo){
			this.orderInfo=orderInfo;
		}
		@Override
		public void run() {
			try {
				orderAllotService.allotOrder(orderInfo);
			} catch (Exception e) {
				logger.error("95511同步进行派单发生异常！", e);
			}		
		}
		
	}

 CustomThreadPoolExecutor pool = new CustomThreadPoolExecutor();

代码中调用:
pool.getCustomThreadPoolExecutor().execute(new AllotTask(orderInfo2)); //多线程的方式下单

 

转载于:https://my.oschina.net/u/3278373/blog/955294