Adds new Divide and Conquer Pattern and some fix

Author: LeonardoZ

README.md

@@ -49,6 +49,7 @@ Concurrency Patterns and features found in Java, through multithreaded programmi
 * [Task Convergence](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/patterns/task_convergence/TaskConvergence.java)
 * [Non-Blocking with Atomics](https://github.com/LeonardoZ/java-concurrency-patterns/tree/master/src/main/java/br/com/leonardoz/patterns/non_blocking)
 * [Controlled Concurrent Initialization](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/patterns/controlled_initialization/ControlledInitialization.java)
+* [Parallel Divide and Conquer](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/patterns/divideconquer/)
 
 ## About
 Patterns and Algorithms inspired by the Java Concurrency in Practice book.

src/main/java/br/com/leonardoz/features/forkjoin/UsingForkJoinFramework.java

@@ -7,7 +7,6 @@
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.RecursiveAction;
 import java.util.concurrent.RecursiveTask;
-import java.util.concurrent.TimeUnit;
 
 /**
  * 
@@ -202,11 +201,6 @@ public static void main(String[] args) {
 		RecSumTask task = new RecSumTask(numbers);
 		BigInteger result = commonPool.invoke(task);
 		System.out.println("Result is: " + result);
-		try {
-			commonPool.awaitTermination(4, TimeUnit.SECONDS);
-		} catch (InterruptedException e) {
-			e.printStackTrace();
-		}
 		System.out.println("\n\n");
 	}
 

src/main/java/br/com/leonardoz/patterns/divideconquer/DivideAndConquer.java

@@ -0,0 +1,53 @@
+package br.com.leonardoz.patterns.divideconquer;
+
+import java.util.List;
+import java.util.concurrent.RecursiveTask;
+
+/*
+ * Pattern: Parallel Divide and Conquer
+ * 
+ * Motivations: Some kind of tasks, algorithms or flows can be divided 
+ * into smaller pieces, which are independently	resolvable, making them fall 
+ * into the category of divide and conquer computations. Those properties 
+ * allows the execution to be parallel, possible increasing the speed if those 
+ * problems were difficult enough to compensate the cost involved in parallelization.
+ * 
+ * Intent: Make the execution of some computation that uses the divide and conquer 
+ * approach parallel, in order to increase performance if the problem difficulty is 
+ * enough to overcome the overhead of using threads and coordination. It uses the ForkJoin Framework 
+ * to model those problems.
+ *
+ * Applicability: Divide and conquer computations.
+ * 
+ */
+public class DivideAndConquer {
+
+	private final static int THRESHOLD = 10; // Choosing a number to split the computation
+	
+	
+	public static class Task extends RecursiveTask<Integer> {
+
+		private static final long serialVersionUID = 1L;
+		private List<Integer> somethingToDivideAndConquer;
+
+		public Task(List<Integer> somethingToDivideAndConquer) {
+			this.somethingToDivideAndConquer = somethingToDivideAndConquer;
+		
+		}
+		
+		@Override
+		protected Integer compute() {
+			int size = somethingToDivideAndConquer.size();
+			if (size < THRESHOLD) {
+				// solves directly
+				return 1;
+			} else {
+				// creates tasks, fork and join
+				return 2;
+			}
+		}
+		
+	}
+	
+	
+}

src/main/java/br/com/leonardoz/patterns/divideconquer/ParallelSum.java

@@ -0,0 +1,102 @@
+package br.com.leonardoz.patterns.divideconquer;
+
+import java.math.BigInteger;
+import java.util.List;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.RecursiveTask;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+/*
+ * Pattern: Parallel Divide and Conquer
+ * 
+ * Example: Parallel Sum
+ */
+public class ParallelSum extends RecursiveTask<BigInteger> {
+
+	private static final long serialVersionUID = 1L;
+	private final static int THRESHOLD = 10_000; // Choosing a number to split the computation
+
+	private List<BigInteger> nums;
+
+	public ParallelSum(List<BigInteger> nums) {
+		this.nums = nums;
+	}
+
+	@Override
+	protected BigInteger compute() {
+		int size = nums.size();
+		if (size < THRESHOLD) {
+			return sequentialSum(nums);
+		} else {
+			ParallelSum x = new ParallelSum(nums.subList(0, size / 2));
+			ParallelSum y = new ParallelSum(nums.subList(size / 2, size));
+			x.fork();
+			y.fork();
+			BigInteger xResult = x.join();
+			BigInteger yResult = y.join();
+			return yResult.add(xResult);
+		}
+	}
+
+	/*
+	 * Just showing how to use the pattern and some really dummy benchmark. Don't
+	 * take it seriously.
+	 */
+	public static void main(String[] args) throws InterruptedException {
+		List<BigInteger> nums = LongStream.range(0, 10_000_000L).mapToObj(BigInteger::valueOf)
+				.collect(Collectors.toList());
+
+// 		Run one then comment and run another
+		Runnable parallel = () -> {
+			ForkJoinPool commonPool = ForkJoinPool.commonPool();
+			BigInteger result = commonPool.invoke(new ParallelSum(nums));
+
+			System.out.println("Parallel Result is: " + result);
+		};
+
+		Runnable sequential = () -> {
+			BigInteger acc = sequentialSum(nums);
+
+			System.out.println("Sequential Result is: " + acc);
+		};
+
+		sequential.run();
+		parallel.run();
+
+		Thread.sleep(2000);
+
+		System.out.println("#### After some JIT \n\n");
+
+		dummyBenchmark(sequential);
+		dummyBenchmark(parallel);
+
+		Thread.sleep(2000);
+
+		System.out.println("#### After more JIT \n\n");
+
+		dummyBenchmark(sequential);
+		dummyBenchmark(parallel);
+	}
+
+	private static BigInteger sequentialSum(List<BigInteger> nums) {
+		BigInteger acc = BigInteger.ZERO;
+		for (BigInteger value : nums) {
+			acc = acc.add(value);
+		}
+		return acc;
+	}
+
+	static void getHot(Runnable runnable) {
+		runnable.run();
+	}
+
+	static void dummyBenchmark(Runnable runnable) {
+		long before = System.currentTimeMillis();
+		runnable.run();
+		long after = System.currentTimeMillis();
+		System.out.println("Executed in: " + (after - before));
+		System.out.println("######\n");
+	}
+
+}