Java多线程Master-Worker模式

Java多线程Master-Worker模式，多适用于需要大量重复工作的场景中。

例如：使用Master-Worker计算0到100所有数字的立方的和

　　1.Master接收到100个任务，每个任务需要0到100中每个数字的立方，这里为了效果，每个任务再sleep一秒，

　　　Master需要将这些任务放到一个支持高并发的非阻塞队列queue中如：ConcurrentLinkedQueue<E>。

　　2.Master创建10个worker去执行这100个任务，并准备一个支持高并发且线程安全的hashMap作为结果集的容器如：ConcurrentHashMap。

　　3.每个worker需要循环的从queue中获取任务然后执行，执行完毕后把结果放到hashMap中，直到queue为空，所有任务执行完毕后退出。

　　4.Master循环判断结果集hashMap中是否有已经执行完毕的结果，如果有就使用，使用完毕就立即移除该结果，直到所有的线程都退出。

　　5.所有任务执行完毕，Master也处理完所有任务的结果，程序结束

Master不需要等待所有的任务执行完毕就可以处理已完成的任务结果，Master和worker可以同时进行工作，这样节省了大量等待worker执行结束的时间

Master源码

package masterWorker;

import java.lang.Thread.State;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

import org.junit.Test;

public class Master {
	public static void main(String[] args) {
		long befor = System.currentTimeMillis();

		//任务队列
		Queue<Integer> taskQueue = new ConcurrentLinkedQueue<>();
		//工人map
		Map<String,Thread> workers = new HashMap<>();
		//结果集
		Map<String,Long> resultMap = new ConcurrentHashMap<>();
		//最终结果
		long result = 0;

		//提交100个任务
		for (int i = 0; i < 100; i++) {
			taskQueue.add(i);
		}

		//添加10个工人
		for (int i = 0; i < 10; i++) {
			workers.put(i+"", new Thread(new Worker(taskQueue,resultMap),"工人"+i));
		}

		//启动所有工人线程
		Collection<Thread> threads = workers.values();
		for (Thread thread : threads) {
			thread.start();
		}

		while(resultMap.size() > 0 || !isComplete(workers)){
			Set<String> keySet = resultMap.keySet();

			//每次从resultMap中取一个结果出来进行使用
			String key = null;
			for (String string : keySet) {
				if(string != null){
					key = string;
					break;
				}
			}
			Long value = null;
			if(key != null){
				value = resultMap.get(key);
			}

			//能取到结果就使用，没有结果继续循环
			if(value != null){
				//获取到一个运算结果就使用
				result = result+value;
				//使用后从结果集中移除
				resultMap.remove(key);
			}

		}
		long after = System.currentTimeMillis();
		System.out.println("结果耗时："+(after - befor));
		System.out.println(result);

	}

	/**
	 * 判断所有的工人是否已经完成工作
	 * @param workers
	 * @return
	 */
	private static boolean isComplete(Map<String,Thread> workers){
		for (Entry<String, Thread> entry : workers.entrySet()) {
			if(entry.getValue().getState() != State.TERMINATED){
				return false;
			}
		}
		return true;
	}

	@Test
	public void test() throws InterruptedException{
		long befor = System.currentTimeMillis();
		long result = 0;

		for (int i = 0; i < 100; i++) {

			long cube = i*i*i;
			result = result+cube;
			Thread.sleep(100);

		}
		long after = System.currentTimeMillis();
		System.out.println("结果耗时："+(after - befor));
		System.out.println(result);
	}
}

　　

　　

Worker源码

package masterWorker;

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

public class Worker implements Runnable{
	private Queue<Integer> queue;
	private Map<String,Long> resultMap;

	public Worker(Queue<Integer> queue,Map<String,Long> resultMap) {
		this.queue = queue;
		this.resultMap = resultMap;
	}

	@Override
	public void run() {
		//不断循环从队列中取出任务进行运算，直到队列为空
		while(true){
			if(queue.peek() != null){
				String name = Thread.currentThread().getName();
				int poll =(int) queue.poll();
				long result = poll*poll*poll;
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				resultMap.put(poll+"", result);
				System.out.println(name+"完成"+poll+"的运算，结果为："+result);
			}else{
				break;
			}
		}
	}
}

　　

经典的Master-Worker源码实例

package masterWorker.classics;
import java.util.Map;
import java.util.Set;  

public class Main {  

    /**
     * @param args
     */
    public static void main(String[] args) {
        //固定使用5个Worker，并指定Worker
        Master m = new Master(new PlusWorker(), Runtime.getRuntime().availableProcessors());
        //提交100个子任务
        for(int i=0;i<100;i++){
            m.submit(i);
        }
        //开始计算
        m.execute();
        int re= 0;
        //保存最终结算结果
        Map<String ,Object> resultMap =m.getResultMap();  

        //不需要等待所有Worker都执行完成，即可开始计算最终结果
        while(resultMap.size()>0 || !m.isComplete()){
            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);
            }  

        }
        System.out.println(re);
    }  

}  

package masterWorker.classics;
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);
        }
    }  

}  

package masterWorker.classics;
public class PlusWorker extends Worker {  

    @Override
    public Object handle(Object input) {  

        Integer i =(Integer)input;
        return i*i*i;
    }  

}  

package masterWorker.classics;
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 boolean isComplete() {
		for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
			if (entry.getValue().getState() != Thread.State.TERMINATED) {
				return false;
			}

		}
		return true;
	}

	// Master的构造，需要一个Worker进程逻辑，和需要Worker进程数量
	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 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();

		}
	}

}