業務場景：

如查一個數據集合，第一頁至第一百頁，返回總頁數的總結集，然後匯出。

一次需要limit 0 10000,這樣，一個SQL查詢出非常慢。

但用100個執行緒，一個執行緒只查limit0 10 就非常快了，

利用多執行緒的特性，返回多個集合，在順序合併成總集合。

下面是concurrent.Future  例子

           concurrent.Callable

package com.test.thread;

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Future;  
  
/**
 *  Future<List<User>>
 *  
 *  應用場景 ：1.多執行緒，每個執行緒平均任務耗時一樣
 *          2.需要順序返回的
 *          
 *  順序返回，如多個分頁，但第一頁需要先返回
 *  
 * @author 汪興安
 *
 */
public class ThreadTest {  
  
    /**
     * 定義執行緒池
     */
    public static ExecutorService executos = Executors.newFixedThreadPool(5);  
  
    public static void main(String[] args) {  
        /**
         * 定義集合裝結果集
         */
        List<User> totalList = new ArrayList<User>();  
        
        /**
         * 定義 Future泛型的集合物件，裝多執行緒的，返回資訊
         */
        List<Future<List<User>>> list = new ArrayList<Future<List<User>>>();  
        try {  
            int pageIndex = 0;  
            int maxPage = 6;  
            for (pageIndex = 0; pageIndex < maxPage; pageIndex++) {  
                /**
                 * executos.submit 返回執行緒未來結果
                 */
                Future<List<User>> future = executos.submit(new DemoThread(pageIndex));  
                list.add(future);  
            }  
  
            for (Future<List<User>> dataFuture : list) {  
                //// 獲得第一個任務的結果，如果呼叫get方法，當前執行緒會等待任務執行完畢後才往下執行
                totalList.addAll(dataFuture.get());  //dataFuture.get()  這裡會阻塞   有順序的哦
            }  
            
            //得到分頁後結果總共集合
            for (int i = 0; i < totalList.size(); i++) {
                System.out.println(totalList.get(i).getName());
            }
            
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        
        executos.shutdownNow();
    }  
  
    
    /**
     *  查詢第1頁
        查詢第3頁
        查詢第5頁
        查詢第2頁
        查詢第4頁
        查詢第0頁
        -----結果會順序返回，不用你操心順序問題啦
        anan0
        anan1
        anan2
        anan3
        anan4
        anan5

     */
}  
 

package com.test.thread;

import java.util.ArrayList;
import java.util.List;  
import java.util.concurrent.Callable;  
  
/**
 * Callable 支援有返回值的多執行緒
 * @author 汪興安
 *
 */
public class DemoThread implements Callable<List<User>> {  
    private int pageIndex;  
  
    /**
     * 通過構造器，初始化
     * @param pageIndex
     */
    public DemoThread(int pageIndex) {  
        this.pageIndex = pageIndex;  
    }  
  
    @Override  
    public List<User> call() throws Exception {  
        //模擬每個執行緒執行耗時不一樣
        if(pageIndex%2==0)
        {
            Thread.sleep(5000);
        }else
        {
            Thread.sleep(2000);
        }
        
        System.out.println("查詢第" + pageIndex + "頁");  
        List<User> list = new ArrayList<User>();  
        
        /**
         * 模擬查詢的資料物件
         */
        User user=new User();
        user.setAge(""+pageIndex);
        user.setName("anan"+pageIndex);
        
        list.add(user);  
        return list;  
    }  
  
}  

 

===================================華麗分割線=================================================================================

package com.test.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutionException;

/**
 * 
 * @author 汪興安
 * 應用場景 ：1.每個執行緒耗時差別大，誰先完成，誰返回
 *           對順序沒有要求。
 * 
 * 
 * 
 * CompletionService 的效能更高。
 * 考慮如下場景：多執行緒下載，結果用Future返回。
 * 第一個檔案特別大，後面的檔案很小。
 * 用方法1，能很快知道已經下載完檔案的結果(不是第一個)；
 *
 */
public class CallableAndFuture {
	
	 public static void main(String[] args) {
		  List<User> totalList = new ArrayList<User>();  
		  
	        ExecutorService threadPool = Executors.newCachedThreadPool();
	        CompletionService<List<User>> cs = new ExecutorCompletionService<List<User>>(threadPool);
	        for(int i = 0; i < 6; i++) {
	            cs.submit(new DemoThread(i));
	        }
	        // 可能做一些事情
	        for(int i = 0; i < 6; i++) {
	            try {
	                totalList.addAll(cs.take().get());
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            } catch (ExecutionException e) {
	                e.printStackTrace();
	            }
	        }
	        
	        //得到分頁後結果總共集合
            for (int i = 0; i < totalList.size(); i++) {
            	System.out.println(totalList.get(i).getName());
			}          
	    }
	 /**
	  * 查詢第3頁
		查詢第1頁
		查詢第5頁
		查詢第2頁
		查詢第0頁
		查詢第4頁
		anan5
		anan1
		anan3
		anan2
		anan0
		anan4
	  */

}
 

總結：兩種方式，應用場景不一樣

         Future<List<User>> future = executos.submit(new DemoThread(pageIndex));   這種可以保證返回的順序  

        CompletionService<List<User>> cs = new ExecutorCompletionService<List<User>>(threadPool);，返回不保證順序，誰先執行完，誰先返回。

        效率上CompletionService更高，實際專案需要根據具體業務需求選擇。