Fork-Join分治编程总结(1)

待我称王封你为后i 2022-02-24 14:20 170阅读 0赞

### 在JDK1.7版本中提供了Fork/Join并行执行任务框架，它的主要作用是把大任务分割成若干个小任务，再对每个小任务得到的结果进行汇总，此种开发方法也叫分治编程，分治编程可以极大地利用CPU资源，提高任务执行的效率，也是目前与多线程有关的前沿技术。在JDK1.7中实现分治编程需要使用ForkJoinPool类，此类的主要作用是创建一个任务池，但其却不能执行具体任务，而要由ForkJoinTask类来执行。类ForkJoinTask是抽象类，不能实例化，所以需要该类的3个子类CountedCompleter,RecursiveAction和RecursiveTask来实现具体功能。 ###

### 1.使用RecursiveAction分解任务 ###

使用类RecursiveAction执行的任务是具有无返回值的，仅执行一次任务。在调用ForkJoinTask.java类中的fork()方法时需要注意一下效率的问题，因为每一次调用fork()都会分离任务，增加系统运行负担，所以在ForkJoinTask.java类中提供了public static void invokeAll(ForkJoinTask<?> t1,ForkJoinTask<?> t2)方法来优化执行效率。

package action;
    
    import java.util.concurrent.RecursiveAction;
    
    public class MyRecursiveAction extends RecursiveAction {
    
    	private int beginValue;
    	private int endValue;
    
    	public MyRecursiveAction(int beginValue, int endValue) {
    		super();
    		this.beginValue = beginValue;
    		this.endValue = endValue;
    	}
    
    	@Override
    	protected void compute() {
    		System.out.println(Thread.currentThread().getName() + " -------");
    		if (endValue - beginValue > 2) {
    			int middelNum = (beginValue + endValue) / 2;
    			MyRecursiveAction leftAction = new MyRecursiveAction(beginValue, middelNum);
    			MyRecursiveAction rightAction = new MyRecursiveAction(middelNum + 1, endValue);
    			this.invokeAll(leftAction, rightAction);
    		} else {
    			System.out.println("打印组合为：" + beginValue + "-" + endValue);
    		}
    	}
    }

package test;
    
    import java.util.concurrent.ForkJoinPool;
    import action.MyRecursiveAction;
    
    public class Test {
    
    	public static void main(String[] args) throws InterruptedException {
    		ForkJoinPool pool = new ForkJoinPool();
    		pool.submit(new MyRecursiveAction(1, 10));
    		Thread.sleep(5000);
    	}
    }

### 2.使用RecursiveTask取得返回值与join()和get()方法的区别 ###

使用类RecursiveTask执行的任务具有返回值的功能。

package mytask;
    
    import java.util.concurrent.RecursiveTask;
    
    public class MyRecursiveTask extends RecursiveTask<Integer> {
    	@Override
    	protected Integer compute() {
    		System.out.println("compute time=" + System.currentTimeMillis());
    		return 100;
    	}
    }

package test;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.ForkJoinTask;
    
    import mytask.MyRecursiveTask;
    
    public class Test1 {
    
    	public static void main(String[] args) {
    		try {
    			MyRecursiveTask task1 = new MyRecursiveTask();
    			System.out.println(task1.hashCode());
    			ForkJoinPool pool = new ForkJoinPool();
    			ForkJoinTask task2 = pool.submit(task1);
    			System.out.println(task2.hashCode() + " " + task2.get());
    			Thread.sleep(5000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		} catch (ExecutionException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

package test;
    
    import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.ForkJoinTask;
    
    import mytask.MyRecursiveTask;
    
    public class Test2 {
    
    	public static void main(String[] args) {
    		try {
    			MyRecursiveTask task1 = new MyRecursiveTask();
    			System.out.println(task1.hashCode());
    			ForkJoinPool pool = new ForkJoinPool();
    			ForkJoinTask task2 = pool.submit(task1);
    			System.out.println(task2.hashCode() + " " + task2.join());
    			Thread.sleep(5000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

### 3.使用RecursiveTask执行多个任务，并取得返回值 ###

package task;
    
    import java.util.concurrent.RecursiveTask;
    
    public class MyRecursiveTaskA extends RecursiveTask<Integer> {
    
    	@Override
    	protected Integer compute() {
    		try {
    			System.out.println(Thread.currentThread().getName() + " begin A " + System.currentTimeMillis());
    			Thread.sleep(3000);
    			System.out.println(Thread.currentThread().getName() + "   end A " + System.currentTimeMillis());
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		return 100;
    	}
    }

package task;
    
    import java.util.concurrent.RecursiveTask;
    
    public class MyRecursiveTaskB extends RecursiveTask<Integer> {
    
    	@Override
    	protected Integer compute() {
    		try {
    			System.out.println(Thread.currentThread().getName() + " begin B " + System.currentTimeMillis());
    			Thread.sleep(5000);
    			System.out.println(Thread.currentThread().getName() + "   end B " + System.currentTimeMillis());
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		return 100;
    	}
    
    }

package test;
    
    import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.ForkJoinTask;
    
    import task.MyRecursiveTaskA;
    import task.MyRecursiveTaskB;
    
    public class Test {
    
    	public static void main(String[] args) throws InterruptedException {
    		ForkJoinPool pool = new ForkJoinPool();
    		ForkJoinTask<Integer> runTaskA = pool.submit(new MyRecursiveTaskA());
    		ForkJoinTask<Integer> runTaskB = pool.submit(new MyRecursiveTaskB());
    		System.out.println("准备打印：" + System.currentTimeMillis());
    		System.out.println(runTaskA.join() + " A：" + System.currentTimeMillis());
    		System.out.println(runTaskB.join() + " B：" + System.currentTimeMillis());
    		Thread.sleep(5000);
    	}
    }

### 4.使用RecursiveTask实现字符串累加 ###

package task;
    
    import java.util.concurrent.RecursiveTask;
    
    public class MyRecursiveTask extends RecursiveTask<String> {
    
    	private int beginValue;
    	private int endValue;
    
    	public MyRecursiveTask(int beginValue, int endValue) {
    		this.beginValue = beginValue;
    		this.endValue = endValue;
    	}
    
    	@Override
    	protected String compute() {
    		System.out.println(Thread.currentThread().getName() + " -----------");
    		if (endValue - beginValue > 2) {
    			int middelValue = (endValue + beginValue) / 2;
    
    			MyRecursiveTask leftTask = new MyRecursiveTask(beginValue, middelValue);
    			MyRecursiveTask rightTask = new MyRecursiveTask(middelValue + 1, endValue);
    
    			this.invokeAll(leftTask, rightTask);
    
    			return leftTask.join() + rightTask.join();
    		} else {
    			String returnString = "";
    			for (int i = beginValue; i <= endValue; i++) {
    				returnString = returnString + (i);
    			}
    			System.out.println("else返回：" + returnString + "     " + beginValue + " " + endValue);
    			return returnString;
    		}
    	}
    }

package test;
    
    import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.ForkJoinTask;
    
    import task.MyRecursiveTask;
    
    public class Test {
    
    	public static void main(String[] args) throws InterruptedException {
    		ForkJoinPool pool = new ForkJoinPool();
    		MyRecursiveTask task = new MyRecursiveTask(1, 20);
    		ForkJoinTask<String> runTaskA = pool.submit(task);
    		System.out.println(runTaskA.join());
    		Thread.sleep(5000);
    	}
    }

### 5.使用Fork-Join实现求和 ###

package mytask;
    
    import java.util.concurrent.RecursiveTask;
    
    public class MyRecursiveTask extends RecursiveTask<Integer> {
    
    	private int beginPosition;
    	private int endPosition;
    
    	public MyRecursiveTask(int beginPosition, int endPosition) {
    		super();
    		this.beginPosition = beginPosition;
    		this.endPosition = endPosition;
    		System.out.println("# " + (beginPosition + " " + endPosition));
    	}
    
    	protected Integer compute() {
    		System.out.println(Thread.currentThread().getName() + "----------------");
    		Integer sumValue = 0;
    		System.out.println("compute=" + beginPosition + " " + endPosition);
    		if ((endPosition - beginPosition) != 0) {
    			System.out.println("!=0");
    			int middleNum = (endPosition + beginPosition) / 2;
    			System.out.println("left  传入的值:" + (beginPosition + " " + middleNum));
    			MyRecursiveTask leftTask = new MyRecursiveTask(beginPosition, middleNum);
    			System.out.println("right 传入的值:" + ((middleNum + 1) + " " + endPosition));
    			MyRecursiveTask rightTask = new MyRecursiveTask(middleNum + 1, endPosition);
    
    			this.invokeAll(leftTask, rightTask);
    
    			Integer leftValue = leftTask.join();
    			Integer rightValue = rightTask.join();
    
    			return leftValue + rightValue;
    
    		} else {
    			return endPosition;
    		}
    	}
    }

package test.run;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ForkJoinPool;
    
    import mytask.MyRecursiveTask;
    
    public class Run {
    
    	public static void main(String[] args) throws InterruptedException {
    		try {
    			MyRecursiveTask task = new MyRecursiveTask(1, 10);
    			ForkJoinPool pool = new ForkJoinPool();
    			pool.submit(task);
    			System.out.println("结果值为：" + task.get());
    		} catch (ExecutionException e) {
    			e.printStackTrace();
    		}
    	}
    }

本例子的核心条件是if ((endPosition - beginPosition)!= 0)代码，也就是想实现1+2+3+4+5......的方式累加到10

package mytask;
    
    import java.util.concurrent.RecursiveTask;
    
    public class MyRecursiveTask extends RecursiveTask<Integer> {
    
    	private int beginPosition;
    	private int endPosition;
    
    	public MyRecursiveTask(int beginPosition, int endPosition) {
    		super();
    		this.beginPosition = beginPosition;
    		this.endPosition = endPosition;
    		System.out.println("# " + (beginPosition + " " + endPosition));
    	}
    
    	protected Integer compute() {
    		Integer sumValue = 0;
    		System.out.println("compute=" + beginPosition + " " + endPosition);
    		if ((endPosition - beginPosition) > 2) {
    			System.out.println("!=0");
    			int middleNum = (endPosition + beginPosition) / 2;
    			System.out.println("left  传入的值:" + (beginPosition + " " + middleNum));
    			MyRecursiveTask leftTask = new MyRecursiveTask(beginPosition, middleNum);
    			System.out.println("right 传入的值:" + ((middleNum + 1) + " " + endPosition));
    			MyRecursiveTask rightTask = new MyRecursiveTask(middleNum + 1, endPosition);
    
    			this.invokeAll(leftTask, rightTask);
    
    			Integer leftValue = leftTask.join();
    			Integer rightValue = rightTask.join();
    
    			return leftValue + rightValue;
    
    		} else {
    			int count = 0;
    			for (int i = beginPosition; i <= endPosition; i++) {
    				count = count + i;
    			}
    			return count;
    		}
    	}
    }

### 本例子的核心条件是if ((endPosition - beginPosition) > 2)代码,也就是可以使用else\{\}中的for循环以数字范围的方式进行累加求和 ###