ExecutorService

今天小編要分享的是關於執行緒池，

想必接觸到併發處理的朋友都有用到執行緒池，

當我們訪問伺服器的量達到伺服器一定量的時候，

比如幾百萬幾千萬，很容易造成伺服器崩掉，

如果使用執行緒進行併發處理，將使用的執行緒進行回收在使用，就減小了伺服器的壓力

下面寫一個例子介紹執行緒池的使用方法：

package com.dstech.market.service.impl;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Component;

import com.dstech.dssp.base.annotation.MethodParameter;
import com.dstech.dssp.comp.bomf.manager.BomfManager;
import com.dstech.dssp.service.BasicBeanService;
import com.dstech.market.bean.DsDocInfo;
import com.dstech.market.service.DsDocInfoService;

/**
* DsDocInfoServiceImpl.java
*/
@Component("marketDsDocInfoService")
@DependsOn({"bomfManager"})
public class DsDocInfoServiceImpl  extends BasicBeanService<DsDocInfo> implements DsDocInfoService {
	//log
private static Logger log=LoggerFactory.getLogger(DsDocInfoServiceImpl.class);
//建立執行緒池
private static  ExecutorService newCachedThreadPool =newFixedThreadPool1(10);
//wx7e3c48ae7772ee10  wx3f465fb88215de20
@Override
public Class<?> getType() {
	return DsDocInfoService.class;
}

/**
 * 初始化
 */
@PostConstruct
public void init(){
	BomfManager.getInstance().addApi(this);
}

/**
 * 查詢
 */
@Override
@MethodParameter(desc="DsInfoQuery", input="Id",postType={},postName="",queryString="",httpMethod="get")
public List<DsDocInfo> DsInfoQuery(String Id) throws Exception {
	List<DsDocInfo> dicInfo=this.getBeanDaoHelper().queryWhere(DsDocInfo.class, "doc_id=?", new Object[]{Id}, null);
	return dicInfo;	
}


/**
 * 執行緒池
 * newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒； 
 * newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待； 
 * newScheduledThreadPool 建立一個定長執行緒池，支援定時及週期性任務執行； 
 * newSingleThreadExecutor 建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行； 
 **/			 
@Override
@MethodParameter(desc="dsquery", input="Id",postType={},postName="",queryString="",httpMethod="get")
public List<DsDocInfo> dsquery(final String Id) throws Exception {
	
	for (int i = 0; i <20; i++){
        newCachedThreadPool.execute(new Runnable(){
            public void run() {
                try {
                    System.out.println("執行緒名稱為："+Thread.currentThread().getName());
                    System.out.println("執行緒Id為："+Thread.currentThread().getId());
                    //休眠時間0.2秒
                    Thread.sleep(200);
                    try {
                    	//呼叫查詢方法
                    	List<DsDocInfo> list=DsInfoQuery(Id);
                    	if(list!=null&&list.size()>0){
                    		for (DsDocInfo dsDocInfo : list) {
								System.out.println("文件Id:"+dsDocInfo.getDocId()+"\t建立人:"+dsDocInfo.getCreatePerson());
							}
                    	}
					} catch(Exception e){
						//TODO Auto-generated catch block
						e.printStackTrace();
					}
                } catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
    }
	return null;
}

/**
 * 以下是對執行緒池的設定
  * @Title: newCachedThreadPool 
  * @Description: TODO
  * @param @param nThreads
  * @param @return 
  * @return ExecutorService
  * @throws
 */
public static ExecutorService newCachedThreadPool(int nThreads){
	//5:核心池大小,	5:最大池大小,60L:保活時間，SECONDS秒
	//return new ThreadPoolExecutor(nThreads,nThreads, 60L,TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
	return new ThreadPoolExecutor(nThreads,Integer.MAX_VALUE,1L,TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads){  
	//nThreads核心池大小 ,nThreads最大池大小,0L,保活時間，MILLISECOND毫秒
		return new ThreadPoolExecutor(nThreads,nThreads,0L,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
	}
	
public static ExecutorService newFixedThreadPool1(int nThreads){
	return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
			new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory){
	return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
			new LinkedBlockingQueue<Runnable>(), threadFactory);
}

}
 

好啦，今天的分享就到這裡喔！

記得點一個贊哦，你的贊是小編成功的第一步