线程master-worker

最新推荐文章于 2024-10-23 23:53:18 发布

转载最新推荐文章于 2024-10-23 23:53:18 发布 · 416 阅读

文章标签：

#线程

线程专栏收录该内容

4 篇文章

订阅专栏

本文介绍了使用Java并发编程处理并聚合子任务的过程，通过Master和Worker类实现了任务的分配、执行与结果收集。

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);
       }
		
	}
}

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>();
	//work进程队列
	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 obj){
		workQueue.add(obj);
	}
	
	//返回子任务结果集
	public Map<String,Object> getresultMap(){
		return resultMap;
	}
	
	//开始运行所有的worker进程，进行处理
	public void  execute(){
		for (Map.Entry<String,Thread> entry : threadMap.entrySet()) {
			entry.getValue().start();
		}
	}

}

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

public class PlusWorker extends Worker{
	
	public Object handle(Object input){
		Integer i = (Integer)input;
		return i*i*i;
	}
	
	public static void main(String[] args) {
		
		Master m=new Master(new PlusWorker(), 5);
		
		for (int i = 0; i <100; i++) {
			m.submit(i);
		}
		m.execute();
		int re=0;
		Map<String,Object> resultMap=m.getresultMap();
		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);
	}

}