Adds new Executors types of pools

Author: LeonardoZ

README.md

@@ -19,10 +19,12 @@ Concurrency Patterns and features found in Java, through multithreaded programmi
   *	[ConcurrentHashMap](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/collections/UsingConcurrentCollections.java#L40)
   *	[Blocking Queue](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/collections/UsingConcurrentCollections.java#L141)
 * [Executors](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java)
-  *	[Fixed Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L89)
-  *	[Cached Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L60)
-  *	[Single Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L46)
-  *	[Scheduled Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L117)
+  *	[Fixed Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L97)
+  *	[Cached Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L68)
+  *	[Single Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L54)
+  *	[Scheduled Thread Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L127)
+  *	[Single Thread Scheduled Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L142)
+  *	[Work-Stealing Pool](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java#L159)
 * [Atomics](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/atomics/UsingAtomics.java)
 * [Futures](https://github.com/LeonardoZ/java-concurrency-patterns/tree/master/src/main/java/br/com/leonardoz/features/futures)
   * [FutureTask](https://github.com/LeonardoZ/java-concurrency-patterns/blob/master/src/main/java/br/com/leonardoz/features/futures/UsingFutureTasks.java)

src/main/java/br/com/leonardoz/features/executors/UsingExecutors.java

@@ -3,6 +3,7 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.UUID;
+import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -15,7 +16,7 @@
  * 
  * Executors help us to decouple task submission from execution.
  * 
- * We have 4 types of executors:
+ * We have 6 types of executors:
  * 
  * - Single Thread Executor: Uses a single worker to process tasks.
  * 
@@ -27,6 +28,13 @@
  * 
  * - Scheduled Thread Pool: Bounded thread limit, used for delayed tasks.
  * 
+ * - Single-Thread Scheduled Pool: Similar to the scheduled thread pool, but 
+ * single-threaded, with only one active task at the time. 
+ * 
+ * - Work-Stealing Thread Pool: Based on Fork/Join Framework, applies the
+ * work-stealing algorithm for balancing tasks, with available processors as a
+ * paralellism level.
+ * 
  * And 2 types of tasks:
  * 
  * - execute: Executes without giving feedback. Fire-and-forget.
@@ -117,23 +125,77 @@ public static void usingFixedThreadPool() {
 	public static void usingScheduledThreadPool() {
 		System.out.println("=== ScheduledThreadPool ===");
 		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
-		scheduledThreadPool.scheduleAtFixedRate(
-				() -> System.out.println("Print every 2s"), 0, 2, TimeUnit.SECONDS);
-		scheduledThreadPool.scheduleWithFixedDelay(
-				() -> System.out.println("Print every 2s delay"), 0, 2, TimeUnit.SECONDS);
+		scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println("1) Print every 2s"), 0, 2, TimeUnit.SECONDS);
+		scheduledThreadPool.scheduleAtFixedRate(() -> System.out.println("2) Print every 2s"), 0, 2, TimeUnit.SECONDS);
+		scheduledThreadPool.scheduleWithFixedDelay(() -> System.out.println("3) Print every 2s delay"), 0, 2,
+				TimeUnit.SECONDS);
 
 		try {
 			scheduledThreadPool.awaitTermination(6, TimeUnit.SECONDS);
 			scheduledThreadPool.shutdown();
 		} catch (InterruptedException e) {
 			e.printStackTrace();
 		}
+		System.out.println("\n\n");
+	}
+	
+	public static void usingSingleTreadScheduledExecutor() {
+		System.out.println("=== SingleThreadScheduledThreadPool ===");
+		ScheduledExecutorService singleThreadScheduler = Executors.newSingleThreadScheduledExecutor();
+		singleThreadScheduler.scheduleAtFixedRate(() -> System.out.println("1) Print every 2s"), 0, 2, TimeUnit.SECONDS);
+		singleThreadScheduler.scheduleWithFixedDelay(() -> System.out.println("2) Print every 2s delay"), 0, 2,
+				TimeUnit.SECONDS);
+
+		try {
+			singleThreadScheduler.awaitTermination(6, TimeUnit.SECONDS);
+			singleThreadScheduler.shutdown();
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		System.out.println("\n\n");
+		
 	}
 
+	public static void usingWorkStealingThreadPool() {
+		System.out.println("=== WorkStealingThreadPool ===");
+		ExecutorService workStealingPool = Executors.newWorkStealingPool();
+
+		workStealingPool.execute(() -> System.out.println("Prints normally"));
+
+		Callable<UUID> generatesUUID = UUID::randomUUID;
+		List<Callable<UUID>> severalUUIDsTasks = new LinkedList<>();
+		for (int i = 0; i < 20; i++) {
+			severalUUIDsTasks.add(generatesUUID);
+		}
+
+		try {
+			List<Future<UUID>> futureUUIDs = workStealingPool.invokeAll(severalUUIDsTasks);
+			for (Future<UUID> future : futureUUIDs) {
+				if (future.isDone()) {
+					UUID uuid = future.get();
+					System.out.println("New UUID :" + uuid);
+				}
+			}
+		} catch (InterruptedException | ExecutionException e) {
+			e.printStackTrace();
+		}
+		try {
+			workStealingPool.awaitTermination(6, TimeUnit.SECONDS);
+			workStealingPool.shutdown();
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		System.out.println("\n\n");
+	}
+
+	
+
 	public static void main(String[] args) {
 		usingSingleThreadExecutor();
 		usingCachedThreadPool();
 		usingFixedThreadPool();
 		usingScheduledThreadPool();
+		usingSingleTreadScheduledExecutor();
+		usingWorkStealingThreadPool();
 	}
 }