分布式计算forkJoin模拟

最新推荐文章于 2024-01-13 13:03:52 发布
最新推荐文章于 2024-01-13 13:03:52 发布
阅读量812 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/simba_1986/article/details/54575526
版权

分布式计算ForkJoin原理

ForkJoin是把一个总任务分成多个线程执行，然后把获得的结果进行汇总，已达到快速执行，提高效率。以下Master\worker的形式模拟。

Master：用于接收客户端发来的任务，并把任务分配给指定的worker，并把worker计算的结果进行汇总， 是一个任务的总控制器

Worker：是正真计算的对象，把计算结果返回给Master的一个容器中。

Task:任务，需要计算的任务。

大概结构如下

代码如下

Master

package com.sf.simba.myforkjoin;

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

/**
 * 模拟forkjoin 分布式计算
 * Master为控制器，用于接收客户端发送过来的任务和分配任务到各个worker，
 * 每个worker计算后把结果返回给Master
 * @author 734621
 *
 */
public class Master {
 //1、一个装任务的容器
	private ConcurrentLinkedQueue<Task> taskes = new ConcurrentLinkedQueue<Task>();
 //2、一个装Worker的容器，其中worker是一个线程
	private HashMap<String,Thread> workers = new HashMap<String,Thread>();
 //3、一个装运算结果的容器
	private ConcurrentHashMap<String,Object> result = new ConcurrentHashMap<String,Object>();
 // 统计任务完成情况
	private final CountDownLatch workerComplete;
 //4、初始化worker
	public Master(Worker worker,int taskCount,CountDownLatch countDownLatch){
		//每一个worker都必须要有master的引用，用于分配任务
		worker.setTaskes(taskes);
		//把结果给work，用于计算完后返回给master
		worker.setResult(result);
		this.workerComplete = countDownLatch;
		worker.setCountDownLatch(workerComplete);
		
		for(int i=0;i<taskCount;i++){
			/**
			 * key表示每一个worker的名字，value表示线程执行对象,
			 * 这里创建一个对象即可，不需要创建十个对象，只需创建十个线程即可
			 */
			workers.put("子节点"+i, new Thread(worker));
		}
	}
	
 //5、提交任务
	public void submit(Task task){
		taskes.add(task);
	}
	
   //6、执行任务
	public void execute(){
		for(Map.Entry<String, Thread> mc :workers.entrySet()){
			System.out.println(mc.getKey()+"开始执行.....");
			mc.getValue().start();
		}
	}
	
	public int getResult(){
		int ret = 0;
		for(Map.Entry<String, Object> rs :result.entrySet()){
			ret += (Integer)rs.getValue();
		}
		return ret;
	}
}

Worker 

package com.sf.simba.myforkjoin;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;

/**
 * 执行Master发送过来的任务,并将产生的结果发送给Master
 * @author 734621
 *
 */
public class Worker implements Runnable{
	private ConcurrentLinkedQueue<Task> taskes;
	private ConcurrentHashMap<String,Object> result;
	private CountDownLatch workerComplete;

	public void setTaskes(ConcurrentLinkedQueue<Task> taskes) {
		this.taskes = taskes;
	}
	public void setResult(ConcurrentHashMap<String, Object> result) {
		this.result = result;
	}
	
	@Override
	public void run() {
		Integer output = null;
		while(true){
			Task input = taskes.poll();//拿出一个值并移除
			if(input == null) break;
			output =(Integer)handler(input);
			result.put(Integer.toString(input.getId()), output);
			workerComplete.countDown();
		}
	}
	
	public Object handler(Task input){
		Object output = null;
		try {
			System.out.println(input.getName()+":执行任务中.....");
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		  output = input.getPrice();
		return output;
	}
	public void setCountDownLatch(CountDownLatch workerComplete) {
		this.workerComplete = workerComplete;
		
	}

}
Task 

package com.sf.simba.myforkjoin;

public class Task {
   private int id;
   private String name;
   private int price;
   
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
   
}



Main 测试类 

package com.sf.simba.myforkjoin;

import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class Main {

	public static void main(String[] args) {
		int allTaskCount = 100;//总共100个任务
		//用于统计任务完成情况
		CountDownLatch countDownLatch = new CountDownLatch(allTaskCount);
		Master master = new Master(new Worker(),10,countDownLatch);
		Random random = new Random();
		for(int i=1;i<=allTaskCount;i++){
			Task task = new Task();
			task.setId(i);
			task.setName("任务"+i);
			task.setPrice(random.nextInt(1000));
			master.submit(task);
		}
		
		master.execute();
		try {
			countDownLatch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("总结果为："+master.getResult());
//		while(true){
//			if(master.isComplete()){
//				
//				break;
//			}	
//		}
		

	}

}


结果如下：


子节点0开始执行.....
子节点2开始执行.....
任务1:执行任务中.....
子节点1开始执行.....
任务2:执行任务中.....
子节点4开始执行.....
任务3:执行任务中.....
子节点3开始执行.....
任务4:执行任务中.....
子节点6开始执行.....
任务5:执行任务中.....
子节点5开始执行.....
任务6:执行任务中.....
子节点8开始执行.....
任务7:执行任务中.....
子节点7开始执行.....
任务8:执行任务中.....
子节点9开始执行.....
任务9:执行任务中.....
任务10:执行任务中.....
任务11:执行任务中.....
任务12:执行任务中.....
任务18:执行任务中.....
任务17:执行任务中.....
任务16:执行任务中.....
任务15:执行任务中.....
任务14:执行任务中.....
任务13:执行任务中.....
任务19:执行任务中.....
任务20:执行任务中.....
任务21:执行任务中.....
任务22:执行任务中.....
任务25:执行任务中.....
任务26:执行任务中.....
任务27:执行任务中.....
任务28:执行任务中.....
任务29:执行任务中.....
任务23:执行任务中.....
任务24:执行任务中.....
任务30:执行任务中.....
任务31:执行任务中.....
任务32:执行任务中.....
任务37:执行任务中.....
任务36:执行任务中.....
任务35:执行任务中.....
任务34:执行任务中.....
任务33:执行任务中.....
任务38:执行任务中.....
任务39:执行任务中.....
任务40:执行任务中.....
任务41:执行任务中.....
任务42:执行任务中.....
任务46:执行任务中.....
任务45:执行任务中.....
任务44:执行任务中.....
任务43:执行任务中.....
任务47:执行任务中.....
任务48:执行任务中.....
任务49:执行任务中.....
任务50:执行任务中.....
任务51:执行任务中.....
任务53:执行任务中.....
任务56:执行任务中.....
任务55:执行任务中.....
任务52:执行任务中.....
任务54:执行任务中.....
任务57:执行任务中.....
任务58:执行任务中.....
任务59:执行任务中.....
任务60:执行任务中.....
任务61:执行任务中.....
任务62:执行任务中.....
任务66:执行任务中.....
任务65:执行任务中.....
任务64:执行任务中.....
任务63:执行任务中.....
任务67:执行任务中.....
任务68:执行任务中.....
任务69:执行任务中.....
任务70:执行任务中.....
任务71:执行任务中.....
任务72:执行任务中.....
任务75:执行任务中.....
任务74:执行任务中.....
任务73:执行任务中.....
任务76:执行任务中.....
任务78:执行任务中.....
任务79:执行任务中.....
任务77:执行任务中.....
任务80:执行任务中.....
任务81:执行任务中.....
任务82:执行任务中.....
任务86:执行任务中.....
任务85:执行任务中.....
任务84:执行任务中.....
任务83:执行任务中.....
任务87:执行任务中.....
任务88:执行任务中.....
任务89:执行任务中.....
任务90:执行任务中.....
任务91:执行任务中.....
任务92:执行任务中.....
任务93:执行任务中.....
任务94:执行任务中.....
任务95:执行任务中.....
任务96:执行任务中.....
任务97:执行任务中.....
任务98:执行任务中.....
任务99:执行任务中.....
任务100:执行任务中.....
总结果为：50140

Simba_hua
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
fork-join详解（2）
qfzhaohan的博客
11-12 1300
4.fork-join实战异步读取磁盘文件 本次采用execute异步来启动ForkJoinPool,小伙伴们可以看启动结果跟invoke启动的区别 具体思路: 1.首先拿到我当前这个磁盘下的所有文件遍历循环 2.循环中判断文件是否是目录,如果是目录再次使用递归任务进行任务添加 3.如果不是目录就输出文件路径 4.对添加到目录递归任务集合中的数据再次进行递归 具体代码： public class main { //读取文件任务对象 static class FileTa
什么是ForkJoin
袁的博客
10-08 1992
ForkJoin
ForkJoin详解
qq_14946371的博客
05-24 674
Fork/Join框架是Java 7提供的一种用于并行执行任务的框架，它将大任务分解为若干个小任务,并行执行这些小任务，最终通过合并每个小任务的结果得到大任务的结果。Fork/Join采用的是分而治之的基本思想，分而治之就是将一个复杂的任务，按照规定的阈值划分成多个简单的小任务，然后将这些小任务的结果再进行汇总返回，得到最终的任务。必须首先创建一个ForkJoinTask对象。在分发任务时，需要注意线程安全问题，防止多个线程同时访问共享资源。
Fork/Join 框架详解
swadian2008的博客
05-16 3293
Fork/Join 是一种并行计算模式，用于解决可以被分解成更小的可并行任务的问题。该模式包含两个关键操作：Fork（分解）和Join（合并）。在 Fork/Join 模式中，原始问题被递归地分解为更小的子问题，直到达到可以并行解决的最小单位。这个过程被称为 Fork。每个子问题可以独立地在不同的处理器上执行，并行地求解部分问题。一旦所有的子问题都被解决，就会进行 Join 操作。Join 操作将所有子问题的结果合并为最终的解决方案。
【并发编程篇】详解Forkjoin
小吉妙妙屋
01-13 1574
Fork/Join 是一种在多线程领域中常用的算法或技术，它的核心思想是将大任务分割成若干个小任务，然后将这些小任务分配给多个线程并行处理，最终将结果合并起来。这种思想可以应用于多种场景，例如图像处理、批处理、并行排序等。在 Java 中，Fork/Join 这种思想被封装在了 java.util.concurrent 包中的 ForkJoinPool 类和 RecursiveTask 类中。
分布式计算课程报告.pdf
07-10
【分布式计算课程报告】 分布式计算是一种利用多台计算机协同处理任务的技术，它可以将大型问题分解成许多小部分，由网络中的各个节点并行处理。在本课程报告中，我们探讨了如何利用C#编程语言和OpenMP库进行分布式...
分布式文件系统性能研究.pdf
08-10
例如，通过实验方法对并行I/O进行参数分析和优化，或者利用Fork-Join排队模型对存储系统框架进行模拟并提出参数分析方法。 元数据访问优化研究方面，由于元数据和应用程序数据的存储和访问特性存在差异，可以通过...
消息驱动的分布式方案推演引擎设计.pdf
08-08
此外，使用分治策略的Fork/Join设计，使得处理过程支持并行计算，大大提升了推演引擎的工作效率。 分布式推演引擎的构建涉及到各个模拟对象根据预设的运动模型、行为模式与规则、预设条件生成消息，这些消息通过...
新冠病毒病毒传染模拟.zip
07-27
9. **并行计算**：对于大规模的城市模拟，可能需要利用多核处理器或分布式计算资源，以加快模拟速度。Java和C/C++都有支持并行计算的框架，如Java的Fork/Join框架和C++的OpenMP。 通过这个项目，开发者不仅可以学习...
并行编程模型与语言.pptx
最新发布
04-24
- Java 的 Fork/Join 框架和 Python 的 concurrent.futures 模块是常见的任务并行编程工具。 - **流水线并行模型**： - 计算任务被划分为多个阶段，并允许不同阶段之间的并行执行。 - Valgrind 和 IntelTBB 是...
Java并发编程——ForkJoin详解
热门推荐
Java是世界上最好的语言
11-13 1万+
概念 Fork/Join 框架是 Java7 提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。类似于Java 8中的parallel Stream。 【只能将任务1个切分为两个，不能切分为3个或其他数量】 简单使用 public class ForkJoinExample { //针对一个数字，做计算。 private static final Integer MAX = 200; static class
Fork/Join解读
一个菜鸡的博客
06-29 496
任务会被分发给空闲的工作线程执行，如果一个线程的工作队列为空，它可以从其他线程的队列中窃取任务来执行。提交给 Fork/Join 线程池的任务需要继承 RecursiveTask（有返回值）或 RecursiveAction（没有返回值），例如下 面定义了一个对 1~n 之间的整数求和的任务。所谓的任务拆分，是将一个大任务拆分为算法上相同的小任务，直至不能拆分可以直接求解。Fork/Join 是 JDK 1.7 加入的新的线程池实现，它体现的是一种分治思想，适用于能够进行任务拆分的 cpu 密集型 运算。
Java ForkJoin 简介和应用
weixin_42176639的博客
06-22 1972
Java 并行计算框架 Fork Join 简介和应用 基于分治思想分解任务并处理，工作窃取算法充分利用线程资源
并发编程之ForkJoin并行处理框架
勤于笔记，成于点滴。
03-23 694
通过本篇文章我们知道了ForkJoin并行框架一个将任务‘分而治之’的并行架构，我们可以通过ForkJoinTask 实现一个具体的并行任务类，并用fork()\join()方法实现任务的分解和结果合并，再将ForkJoinTask 通过 ForkJoinPool并行线程池进行submit()创建ForkJoinWorkerThread执行。
Fork/Join的用法
cblstc的博客
08-12 1254
fork/join fork/join采用了分而治之的思想，拿到一个任务，不断分解任务，直到子任务达到某个条件（如小于某个值）即可执行子任务。子任务处理完毕，再把子任务合并。 创建一个继承RecursiveTask（有返回值）或RecursiveAction（无返回值）的任务类，实现compute方法。 调用时，创建一个ForkJoinPool，用来执行/提交任务。了解submit/invoke/execute的区别，在代码里面有注明。 同步用法：计算和 public class ForkJoinSum
Fork/join框架
leimeng123的博客
11-07 3711
1 Frok/Join框架简介 Fork/Join框架是Java7提供了的一个用于并行执行的任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。 Fork 递归地将任务分解为较小的独立子任务，直到它们足够简单以便异步执行。 Join 将所有子任务的结果递归地连接成单个结果，或者在返回void的任务的情况下，程序只是等待每个子任务执行完毕。 比如计算 1+2+......+10000，可以分割成10个子任务，每个子任务对1000个数进行求和，最终汇
转：聊聊并发（八）——Fork/Join框架介绍
weixin_30685029的博客
12-24 504
1. 什么是Fork/Join框架 Fork/Join框架是Java7提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。 我们再通过Fork和Join这两个单词来理解下Fork/Join框架，Fork就是把一个大任务切分为若干子任务并行的执行，Join就是合并这些子任务的执行结果，最后得到这个大任务的结果。比如计算1+2+。。...
Fork和Join底层原理
qq_43456605的博客
12-14 961
思考: 线程池的线程数设置多少合适?我们调整线程池中的线程数量的最主要的目的是为了充分并合理地使用 CPU 和内存等资源，从而最大限度地提高程序的性能。在实际工作中，我们需要根据任务类型的不同选择对应的策略。传统线程池ThreadPoolExecutor有两个明显的缺点:一是无法对大任务进行拆分，对于某个任务只能由单线程执行;二是工作线程从队列中获取任务时存在竞争情况。这两个缺点都会影响任务的执行效率。为了解决传统线程池的缺陷，Java7中引入Fork/Join框架，并在Java8中得到广泛应用。
怎样设计分布式计算的模拟
05-26
分布式计算的模拟设计需要考虑以下几个方面： 1. 网络拓扑结构：需要考虑网络拓扑结构的选择，如何建立节点之间的连接、如何管理节点之间的通信等。 2. 任务分配和调度：需要设计一套任务分配和调度机制，将任务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值