假設場景：

某大型網站，活躍使用者上億個。（當然不是指同時線上人數，這裡指的是再一段時間內有訪問操作的使用者數量，比如一個小時內）。

現在要每隔1小時，統計一次活躍使用者排行榜（使用者點選本網站的一個連線，活躍度就加1，按活躍度進行排名）。

首先，在此場景下，解決此問題不涉及資料庫操作（也不可能使用者點選一下，就更新一下資料庫！），訪問記錄就是記錄在日誌檔案中，例如：

zhangsan, http://a.com/b/

zhangsan, http://a.com/c/

lisi, http://a.com/b/

lisi, http://a.com/e/

lisi, http://a.com/x/

然後，我們不考慮使用者訪問量的統計過程，假設根據日誌檔案已經得出了這樣的檔案：

zhangsan 2

lisi 3

其中，2、3分別表示對應使用者的活躍度，我們要按此進行排序，但是使用者總量有一億個！

接著，我們繼續抽象、簡化。既然活躍度用整數表示，我們就單獨來考慮整數排序的問題，即，使用者名稱也先不考慮了，就處理一億個整數的排序。

先嚐試直接使用TreeSet來排序。

TreeSet底層是紅黑樹實現的，排序是很高效的，這裡不深究，我們就用它來完成排序：

1. 生產測試資料

package com.bebebird.data.handler;

import java.io.File;
import java.io.PrintWriter;
import java.util.Random;

/**
 * 
 * @author sundeveloper
 * 
 * 建立測試資料
 *
 */
public class DataProducer {

	/**
	 * 建立資料
	 * @param count 資料量
	 * @param out 輸出檔案路徑
	 */
	public static void produce(int count, String out) {
		long t1 = System.currentTimeMillis();
		File file = new File(out);
		if(file.exists())
			file.delete();
		
		try (PrintWriter writer = new PrintWriter(file, "UTF-8");) {
			Random random = new Random();
			for(int i=0; i<count; i++){
				writer.write(random.nextInt(count) + "\n");
			}
		}catch (Exception e){
			e.printStackTrace();
		}
		long t2 = System.currentTimeMillis();
		System.out.println("建立成功！耗時：" + (t2 - t1) + "毫秒。");
	}
	
}
 

2. 利用TreeSet對資料進行排序：

package com.bebebird.data.handler;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.TreeSet;

/**
 * 
 * @author sundeveloper
 * 
 * 使用TreeSet自動將資料排序
 * 
 * 處理資料量能達到千萬級，一千萬資料排序大約用時20秒。
 *
 */
public class SimpleTreeSetHandler {

	private Integer[] datas = null;
	
	/**
	 * 排序
	 * @param in 資料檔案路徑
	 */
	public void sort(String in){
		long t1 = System.currentTimeMillis();
		File file = new File(in);
		if(!file.exists())
			return;
		
		try(BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file),"UTF-8"));){
			TreeSet<Integer> set = new TreeSet<>();
			String line = null;
			while((line = reader.readLine()) != null && !"".equals(line)){
				set.add(new Integer(line));
			}
			this.datas = set.toArray(new Integer[set.size()]);
		}catch(Exception e){
			e.printStackTrace();
		}
		long t2 = System.currentTimeMillis();
		
		System.out.println("排序完成！耗時：" + (t2 - t1) + "毫秒。");
	}
	
	/**
	 * 從pos開始，獲取count個數
	 * @param pos
	 * @param count
	 * @return
	 */
	public Integer[] limit(int pos, int count){
		long t1 = System.currentTimeMillis();
		if(pos < 0 || count <= 0){
			return null;
		}
		Integer[] result = new Integer[count];
		for (int i = 0; i < count && pos + i < this.datas.length; i++) {
			result[i] = this.datas[pos + i];
		}
		long t2 = System.currentTimeMillis();
		System.out.println("取數成功！耗時：" + (t2 - t1) + "毫秒。");
		return result;
	}
	
	// 測試：
	// 建立1千萬隨機數，進行排序
	public static void main(String[] args) {
		DataProducer.produce(10000000, "data");
		
		SimpleTreeSetHandler handler = new SimpleTreeSetHandler();
		handler.sort("data");
		
		Integer[] limit = handler.limit(10, 10);
		System.out.println(Arrays.asList(limit));
	}
}
 

經測試，直接使用TreeSet來處理，一千萬資料量很輕鬆就能處理，大概排序耗時20秒左右。

但是，一億資料量時就廢了！CPU滿，記憶體佔用上2.5G左右，並且N多分鐘後不出結果，只能結束程序！（有條件的話，可以試試，具體多久能排出來）

機器配置簡要說明：2.5 GHz Intel Core i5，系統記憶體10G。

3. 既然用TreeSet處理一千萬資料很容易，那麼把一億條分成10個一千萬不就能夠處理了？每個一千萬用時20秒，10個一千萬大概200秒，三分鐘拍出來還是可以接受的！（當然，這麼算不準確，但大概是這個數量級的！）

package com.bebebird.data.handler;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

/**
 * 
 * @author sundeveloper
 *
 * 將資料進行分成若干片段；
 * 分別對每個片段進行排序，存入臨時檔案；
 * 將臨時檔案進行合併
 *
 */
public class DivideTreeSetHandler {

	/**
	 * 排序
	 * @param in 資料檔案路徑
	 * @param size 每個資料檔案的大小（行數）
	 */
	public List<String> divide(String in, int size){
		long t1 = System.currentTimeMillis();
		File file = new File(in);
		if(!file.exists())
			return null;
		
		List<String> outs = new ArrayList<String>();
		
		try(BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file),"UTF-8"));){
			int fileNo = 0; // 臨時檔案編號
			Set<Integer> set = new TreeSet<Integer>();
			while(true){
				String line = reader.readLine();
				
				// 讀取結束！
				if(line == null){
					writeSetToTmpFile(set, fileNo, outs);
					break;
				}
				
				// 空行，跳過
				if("".equals(line.trim())){
					continue;
				}
				
				set.add(new Integer(line));
				
				// 資料量達到:
				if(set.size() >= size){
					writeSetToTmpFile(set, fileNo, outs);
					fileNo ++;
				}
			}
			
		}catch(Exception e){
			e.printStackTrace();
		}
		long t2 = System.currentTimeMillis();
		
		System.out.println("拆分完成！耗時：" + (t2 - t1) + "毫秒。");
		
		return outs;
	}
	
	// set資料寫入到檔案中：
	private void writeSetToTmpFile(Set<Integer> set, int fileNo, List<String> outs) {
		long t1 = System.currentTimeMillis();
		File file = new File("tmp_" + fileNo);
		if(file.exists())
			file.delete();
		
		try (PrintWriter writer = new PrintWriter(file, "UTF-8");) {
			Iterator<Integer> iterator = set.iterator();
			while(iterator.hasNext()){
				writer.write(iterator.next() + "\n");
			}
			set.clear();
		}catch (Exception e){
			e.printStackTrace();
		}
		long t2 = System.currentTimeMillis();
		System.out.println("生成臨時檔案：" + file.getAbsolutePath() + "！耗時：" + (t2 - t1) + "毫秒。");
		outs.add(file.getAbsolutePath());
	}
	
	/**
	 * 合併資料
	 * @param ins
	 */
	public String combine(List<String> ins) {
		long t1 = System.currentTimeMillis();
		
		if(ins == null || ins.size() <= 1)
			return null;
		
		File file = new File("tmp");
		if(file.exists())
			file.delete();
		
		try(PrintWriter writer = new PrintWriter(file, "UTF-8");){
			List<BufferedReader> readers = new ArrayList<>();
			for (String in : ins) {
				readers.add(new BufferedReader(new InputStreamReader(new FileInputStream(in),"UTF-8")));
			}
			
			while(readers.size() > 0){
				BufferedReader reader0 = readers.get(0);
				while(true){
					String line = reader0.readLine();
					if(line == null){
						readers.remove(0);
						break;
					}
					if("".equals(line.trim()))
						continue;
					
					// 用個set記錄從多個檔案中取出的資料，這些資料需要繼續排序：
					Set<Integer> set = new TreeSet<Integer>();
					
					int data = new Integer(line);
					
					// 先把data放入set：
					set.add(data);
					
					for(int i = readers.size() - 1; i > 0; i--){
						BufferedReader readeri = readers.get(i);
						while(true){
							// 設定一個標記，如果後邊datai大於data了，需要reset到此處！
							readeri.mark(1024); 
							
							String linei = readeri.readLine();
							if(linei == null){
								readers.remove(i);
								break;
							}
							if("".equals(linei.trim()))
								continue;
							
							int datai = new Integer(linei);
							
							// datai小於data，則把datai放入set，會自動排序
							if(datai < data){
								set.add(datai);
							}
							// datai等於data，則暫時退出，停止讀取
							else if(datai == data){
								break;
							}
							// datai大於data，則往回退一行（退到標記處），停止讀取
							else{
								readeri.reset();
								break;
							}
						}
					}
					
					// 按data查詢，小於data的值，都已經存入set了，此時把set輸出到檔案中：
					Iterator<Integer> iterator = set.iterator();
					while(iterator.hasNext()){
						writer.write(iterator.next() + "\n");
					}
					set.clear();
				}
			}
		}catch(Exception e){
			e.printStackTrace();
		}
		
		long t2 = System.currentTimeMillis();
		System.out.println("合併完成！耗時：" + (t2 - t1) + "毫秒。");
		
		return file.getAbsolutePath();
	}

	/**
	 * 從pos開始，獲取count個數
	 * @param pos
	 * @param count
	 * @return
	 */
	public Integer[] limit(int pos, int count, String in){
		// TODO : 從排序後的檔案中讀取資料即可！不寫了！
		return null;
	}
	
	// 測試：
	public static void main(String[] args) {
		// 資料量：
		int dataCount = 100000000;
		// 分頁數（拆分檔案數）：
		int pageCount = 10;
		// 每頁資料量：
		int perPageCount = dataCount / pageCount;
		
		// 生成一億資料：
		DataProducer.produce(dataCount, "data");
		
		DivideTreeSetHandler handler = new DivideTreeSetHandler();
		
		// 拆分排序：
		List<String> tmps = handler.divide("data", perPageCount);
		
		// 合併排序：
		String tmp = handler.combine(tmps);
		
		// 獲取資料：
		Integer[] limit = handler.limit(10, 10, tmp);
	}

}

呼叫DivideTreeSetHandler的combine()方法，將拆分後的若干個檔案進行合併，合併的過程中同樣也會排序！

最終，輸出一個完全排序了的檔案。

經測試，一億資料量，拆分加合併共用時約3.6分鐘（包含各種IO操作的用時），可以接受。

到這裡，核心問題解決了，剩餘的就是物件排序了，把使用者、活躍度封裝成物件，用TreeSet將物件進行排序，物件實現compareTo，重寫hashcode、equals等等，就不再多說了。

當然，DivideTreeSetHandler的還有很多優化空間，比如，可以把拆分、合併用多執行緒來處理。這裡就先不搞了，有空再說。

說明：

寫程式碼時，並不知道這種排序演算法已經有名字了（叫“歸併排序”），還想著為其命名呢~

實際上，是受到hadoop的map-reduce思想的啟發，想到用這個方法來處理。

思想都是想通的：一個人搞不了了，就要分而治之！