Java多執行緒程式設計中，常用的多執行緒設計模式包括：Future模式、Master-Worker模式、Guarded Suspeionsion模式、不變模式和生產者-消費者模式等。這篇文章主要講述Master-Worker模式，關於其他多執行緒設計模式的地址如下：
關於其他多執行緒設計模式的地址如下：
關於Future模式的詳解： Java多執行緒程式設計中Future模式的詳解
關於Guarded Suspeionsion模式的詳解： Java多執行緒程式設計中Guarded Suspeionsion模式的詳解
關於不變模式的詳解： Java多執行緒程式設計中不變模式的詳解
關於生產者-消費者模式的詳解：生產者-消費者模式Java詳解

1 Master-Worker模式核心思想

Master-Worker模式是常用的並行模式之一，它的核心思想是：系統由兩類程序協同工作，即Master程序和Worker程序，Master負責接收和分配任務，Wroker負責處理子任務。當各個Worker程序將子任務處理完成後，將結果返回給Master程序，由Master程序進行彙總，從而得到最終的結果，其具體處理過程如下圖所示。

Master程序為主要程序，它維護一個Worker程序佇列、子任務佇列和子結果集。Worker程序佇列中的Worker程序不停從任務佇列中提取要處理的子任務，並將結果寫入結果集。

2 Master-Worker模式的程式碼實現

Worker類的Java實現

import java.util.Map;
import java.util.Queue;

public class Worker implements Runnable {
	//任務佇列
	protected Queue<Object> workQueue;
	//子任務處理結果集
	protected Map<String, Object> resultMap;
	public void setWorkQueue(Queue<Object> workQueue) {
		this.workQueue = workQueue;
	}

	public void setResultMap(Map<String, Object> resultMap) {
		this.resultMap = resultMap;
	}
	
	//子任務處理的邏輯，在這裡不作具體實現，由子類實現
	public Object handle(Object input) {
		return input;
	}
	
	@Override
	public void run() {
		while(true) {
			//獲取子任務
			Object input = workQueue.poll();
			if(input == null) break;
			//處理子任務
			Object re = handle(input);
			//將處理結果寫入結果集
			resultMap.put(Integer.toString(input.hashCode()), re);
		}
	}
}
 

Master類的Java實現

import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

public class Master {
	//任務佇列
	protected Queue<Object> workQueue = 
			new ConcurrentLinkedQueue<Object>();
	//Worker程序佇列
	protected Map<String, Thread> threadMap = 
			new HashMap<String, Thread>();
	//子任務處理結果集
	protected Map<String, Object> resultMap =
			new ConcurrentHashMap<String, Object>();
	
	public Master(Worker worker, int countWorker) {
		worker.setWorkQueue(workQueue);
		worker.setResultMap(resultMap);
		for(int i=0; i<countWorker; i++) {
			threadMap.put(Integer.toString(i), 
					new Thread(worker, Integer.toString(i)));
		}
	}
	
	//是否所有的子任務都介紹了
	public boolean isComplete() {
		for(Map.Entry<String, Thread> entry : threadMap.entrySet()) {
			if(entry.getValue().getState() != Thread.State.TERMINATED)
				//存在為完成的執行緒
				return false;
		}
		return true;
	}
	
	//提交一個子任務
	public void submit(Object job) {
		workQueue.add(job);
	}
	
	//返回子任務結果集
	public Map<String, Object> getResultMap() {
		return resultMap;
	}
	
	//執行所有Worker程序，進行處理
	public void execute() {
		for(Map.Entry<String, Thread> entry : threadMap.entrySet()) {
			entry.getValue().start();
		}
	}
}
 

3 Master-Worker模式的應用例項

利用Master-Worker模式實現計算立方和的應用。計算1^3+2^3+3^3+…+100^3。

這個計算任務被劃分成100個子任務，每個任務僅僅用於計算單獨的立方和。

Worker的子類

public class PlusWorker extends Worker { //求立方和
	@Override
	public Object handle(Object input) {
		int i = (Integer)input;
		return i * i * i;
	}
}

執行

執行的呼叫函式如下。在主函式中首先通過Master類建立4個Worker工作程序和Worker工作例項PlusWorker。在提交了100個子任務後，邊開始子任務的計算。這些子任務中由這4個程序共同完成。Master不用等待所有Worker計算完成才開始彙總，而是子任務在計算的過程中，Master就開始彙總了。

import java.util.Map;
import java.util.Set;

public class Application {
	public static void main(String[] args) {
		//固定使用4個Workde
		Master master = new Master(new PlusWorker(), 4);
		for(int i=1; i<=100; i++) //提交100個子任務
			master.submit(i);
		master.execute(); //開始計算
		
		Map<String, Object> resultMap = master.getResultMap();
		
		int re = 0;  //最終計算結果儲存在此
		//不需要等待所有Worker都執行完即可
		while(true) {
			Set<String> keys = resultMap.keySet();  //開始計算最終結果
			String key = null;
			for(String k : keys) {
				key = k;
				break;
			}
			Integer i = null;
			if(key != null)
				i = (Integer)resultMap.get(key);
			if(i != null)
				re += i; //最終結果
			if(key != null)
				resultMap.remove(key); //移除已被計算過的專案
			if(master.isComplete() && resultMap.size()==0)
				break;
		}
		System.out.println(re);
	}
}

執行結果如下：

本文完。轉載請註明出處。

參考文獻
葛一鳴，Java程式效能優化．清華大學出版社．