View difference between Paste ID: zaTwZkTY and PSrEUrPw

 package com.example.foo;
 
 import java.util.Arrays;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ForkJoinTask;
 
 /**
  * https://humanoidreadable.wordpress.com/2014/12/31/forkjoin-nonrecursive-task/
  *
  * @author Claude Martin
  *
-public class SomeClass {
+
 public final class SomeClass {
-  private static class Task1 extends ForkJoinTask<Integer> {
+	/** This is used to fork/join once per entry of the resulting matrix. */
-    private static final long serialVersionUID = 4577085552193799470L;
+	private static class MatrixProduct extends ForkJoinTask<int[][]> {
 		private static final long serialVersionUID = 1527639909439152978L;
-    private final Integer input;
+		private final int[][] A;
-    private Integer result = null;
+		private final int[][] B;
 		private int[][] result = null;
-    public Task1(Integer input) {
+
-      this.input = input;
+		public MatrixProduct(final int[][] A, final int[][] B) {
-    }
+			this.A = A;
 			this.B = B;
-    @Override
+		}
-    public Integer getRawResult() {
+
-      return this.result;
+		@Override
-    }
+		public int[][] getRawResult() {
 			return result;
-    @Override
+		}
-    protected void setRawResult(Integer value) {
+
-      this.result = value;
+		@Override
-    }
+		protected void setRawResult(final int[][] value) {
 			this.result = value;
-    @Override
+		}
-    protected boolean exec() {
+
-      ForkJoinTask<Integer> a = new Task2(this.input).fork();
+		// see https://en.wikipedia.org/wiki/Matrix_multiplication#Definition
-      ForkJoinTask<Integer> b = new Task2(this.input + 1).fork();
+		@Override
-      setRawResult(a.join() + b.join());
+		protected boolean exec() {
-      return true;
+			final int n = A.length;
-    }
+			final int p = B[0].length;
-  }
+			final int m = B.length; // == A[0].length
 			this.result = new int[n][p];
-  private static class Task2 extends ForkJoinTask<Integer> {
+			@SuppressWarnings("unchecked")
-    private static final long serialVersionUID = -7037328571331917872L;
+			final ForkJoinTask<Integer>[][] tasks = new ForkJoinTask[n][p];
-    private final Integer input;
+			if (m != A[0].length) {
-    private Integer result = null;
+				throw new IllegalArgumentException("Can't calculate matrix product for given input");
 			}
-    public Task2(Integer input) {
+			if (n == 0 || p == 0)
-      this.input = input;
+				return true;
-    }
+			for (int i = 0; i < n; i++)
 				for (int j = 0; j < p; j++)
-    @Override
+					tasks[i][j] = new CalculateEntry(A, B, i, j).fork();
-    public Integer getRawResult() {
+			for (int i = 0; i < n; i++)
-      return this.result;
+				for (int j = 0; j < p; j++)
-    }
+					result[i][j] = tasks[i][j].join();
 			return true;
-    @Override
+		}
-    protected void setRawResult(Integer value) {
+	}
-      this.result = value;
+
-    }
+	/** This is used to calculate each entry. It won't create more subtasks. */
 	private static class CalculateEntry extends ForkJoinTask<Integer> {
-    @Override
+		private static final long serialVersionUID = 2781862671220715328L;
-    protected boolean exec() {
+		private final int[][] A;
-      System.out.format("Task2(%d) started%n", this.input);
+		private final int[][] B;
 		private final int i;
-      // This is the actual work:
+		private final int j;
-      setRawResult(this.input * this.input);
+		private Integer result = null;
 
-      // Just to show that they really run in parallel:
+		public CalculateEntry(final int[][] A, final int[][] B, final int i, final int j) {
-      try {
+			this.A = A;
-        Thread.sleep(5000);
+			this.B = B;
-      } catch (InterruptedException e) {
+			this.i = i;
-        e.printStackTrace();
+			this.j = j;
-      }
+		}
 
-      System.out.format("Task2(%d) finished%n", this.input);
+		@Override
-      return true;
+		public Integer getRawResult() {
-    }
+			return this.result;
-  }
+		}
 
-  public static void main(String[] args) {
+		@Override
 		protected void setRawResult(final Integer value) {
-    Integer result = ForkJoinPool.commonPool().invoke(new Task1(5));
+			this.result = value;
-    System.out.println(result);
+		}
 
-    // 5*5 = 25
+		@Override
-    // 6*6 = 36
+		protected boolean exec() {
-    // 25+36= 61
+			int sum = 0;
 			for (int k = 0; k < B.length; k++) {
-  }
+				sum += A[i][k] * B[k][j];
 			}
 			this.setRawResult(sum);
 			return true;
 		}
 	}
 
 	public static void main(String[] args) {
 		// Note: The matrices would have to be much larger to get better performance than
 		// doing the same without parallel execution. But then the output is hard to read.
 		int[][] A = { { 1, 2, 3 }, { 4, 5, 6 } };
 		int[][] B = { { 7, 8 }, { 9, 10 }, { 11, 12 } };
 		int[][] result = ForkJoinPool.commonPool().invoke(new MatrixProduct(A, B));
 		for (int[] row : result)
 			System.out.println(Arrays.toString(row));
 	}
 }