added concurrency examples

Author: alican akkus

src/main/java/com/caysever/java8/concurrency/CallableExample.java

@@ -0,0 +1,55 @@
+package com.caysever.java8.concurrency;
+
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import com.caysever.java8.model.Person;
+import com.caysever.java8.utils.PersonUtil;
+
+/**
+ * @author alican
+ *
+ */
+public class CallableExample {
+
+    public static void main(String[] args) {
+
+	try {
+	    List<Person> persons = PersonUtil.mockPersons();
+
+	    //Callables are functional interfaces just like runnables but instead of being void they return a value.
+	    Callable<List<Person>> personsSortingAndFilteringTask = () -> {
+		try {
+		    TimeUnit.SECONDS.sleep(3);
+		    return persons.stream().sorted((p1, p2) -> p1.getBirthday().compareTo(p2.getBirthday())).filter((p) -> p.getFirstname() != null)
+			    .collect(Collectors.toList());
+		} catch (InterruptedException e) {
+		    throw new IllegalStateException("task interrupted", e);
+		}
+	    };
+
+	    ExecutorService executor = Executors.newFixedThreadPool(1);
+	    Future<List<Person>> future = executor.submit(personsSortingAndFilteringTask);
+	    
+	    //executor.shutdownNow(); dont call this method in this point. executor and callable-future is tightly coupled.
+
+	    System.out.println("future done? " + future.isDone());
+
+	    List<Person> resultOfPersonsTask = future.get();
+	    executor.shutdownNow();// we can shutdown now
+
+	    System.out.println("future done? " + future.isDone());
+	    
+	    resultOfPersonsTask.forEach(System.out::println);
+
+	} catch (Exception e) {
+	    e.printStackTrace();
+	}
+    }
+
+}

src/main/java/com/caysever/java8/concurrency/ExecutorsExample.java

@@ -0,0 +1,51 @@
+package com.caysever.java8.concurrency;
+
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import com.caysever.java8.model.Person;
+import com.caysever.java8.utils.PersonUtil;
+
+/**
+ * @author alican
+ *
+ */
+public class ExecutorsExample {
+
+    public static void main(String[] args) {
+
+	try {
+	    List<Person> persons = PersonUtil.mockPersons();
+
+	    ExecutorService executor = Executors.newSingleThreadExecutor();
+	    executor.submit(() -> {
+		String threadName = Thread.currentThread().getName();// pool-1-thread-1
+		persons.forEach((p) -> System.out.println(threadName + " | " + p));
+	    });
+
+	    executor.submit(() -> {
+		String threadName = Thread.currentThread().getName();// pool-1-thread-1
+		persons.forEach((p) -> System.err.println(threadName + " | " + p));
+	    });
+
+	    // the java process never stops!
+
+	   // executor.shutdown();// Executors have to be stopped explicitly -
+				// waits
+				// for currently running tasks to finish
+
+	    // executor.shutdownNow();// interrupts all running tasks and shut
+	    // the executor down immediately.
+
+	    // or you can this;
+	    System.out.println("attempt to shutdown executor in 15 seconds");
+	    executor.awaitTermination(15, TimeUnit.SECONDS);
+	    
+	} catch (InterruptedException e) {
+	    e.printStackTrace();
+	}
+    }
+
+}

src/main/java/com/caysever/java8/concurrency/FutureTimeoutsExample.java

@@ -0,0 +1,62 @@
+package com.caysever.java8.concurrency;
+
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.Collectors;
+
+import com.caysever.java8.model.Person;
+import com.caysever.java8.utils.PersonUtil;
+
+/**
+ * @author alican
+ *
+ */
+public class FutureTimeoutsExample {
+
+    public static void main(String[] args) {
+
+	try {
+	    List<Person> persons = PersonUtil.mockPersons();
+
+	    //Callables are functional interfaces just like runnables but instead of being void they return a value.
+	    Callable<List<Person>> personsSortingAndFilteringTask = () -> {
+		try {
+		    TimeUnit.SECONDS.sleep(3);
+		    return persons.stream().sorted((p1, p2) -> p1.getBirthday().compareTo(p2.getBirthday())).filter((p) -> p.getFirstname() != null)
+			    .collect(Collectors.toList());
+		} catch (InterruptedException e) {
+		    throw new IllegalStateException("task interrupted", e);
+		}
+	    };
+
+	    ExecutorService executor = Executors.newFixedThreadPool(1);
+	    Future<List<Person>> future = executor.submit(personsSortingAndFilteringTask);
+	    
+
+	    
+	    try{
+		List<Person> resultOfPersonsTask = future.get(1, TimeUnit.SECONDS);//we should getting timeout exception
+		resultOfPersonsTask.forEach(System.out::println);
+	    }catch(TimeoutException te){
+		te.printStackTrace();
+		//java.util.concurrent.TimeoutException
+		// at java.util.concurrent.FutureTask.get(FutureTask.java:205)
+		// at
+		// com.caysever.java8.concurrency.FutureTimeoutsExample.main(FutureTimeoutsExample.java:43)
+
+	    }finally{
+		executor.shutdownNow();
+	    }
+
+
+	} catch (Exception e) {
+	    e.printStackTrace();
+	}
+    }
+
+}

src/main/java/com/caysever/java8/concurrency/MultipleCallablesExample.java

@@ -0,0 +1,53 @@
+package com.caysever.java8.concurrency;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
+
+import com.caysever.java8.model.Person;
+import com.caysever.java8.utils.PersonUtil;
+
+/**
+ * @author alican
+ *
+ */
+public class MultipleCallablesExample {
+
+    public static void main(String[] args) {
+
+	try {
+	    List<Person> persons = PersonUtil.mockPersons();
+
+	    //create callable list which return sorted persons
+	    List<Callable<List<Person>>> callables = Arrays.asList(() -> {
+		System.out.println("Persons sorting by birthday..");
+		return persons.stream().sorted((p1, p2) -> p1.getBirthday().compareTo(p2.getBirthday())).collect(Collectors.toList());
+	    }, () -> {
+		System.out.println("Persons sorting by firstname..");
+		return persons.stream().sorted((p1, p2) -> p1.getFirstname().compareTo(p2.getFirstname())).collect(Collectors.toList());
+	    }, () -> {
+		System.out.println("Persons sorting by lastname..");
+		return persons.stream().sorted((p1, p2) -> p1.getLastname().compareTo(p2.getLastname())).collect(Collectors.toList());
+	    });
+
+	    //create work stealing pool for more than one tasks
+	    ExecutorService executor = Executors.newWorkStealingPool();
+	    
+	    executor.invokeAll(callables).stream().map(future -> {
+		try {
+		    return future.get();
+		} catch (Exception e) {
+		    throw new IllegalStateException(e);
+		}
+	    }).forEach(System.out::println);
+	    
+	    //executor.invokeAny(callables).forEach(System.out::println); // call the invokeAny function for returns the string result of the fastest callable
+
+	} catch (Exception e) {
+	    e.printStackTrace();
+	}
+    }
+}

src/main/java/com/caysever/java8/concurrency/ScheduledExecutorsExample.java

@@ -0,0 +1,31 @@
+package com.caysever.java8.concurrency;
+
+import java.time.LocalDateTime;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author alican
+ *
+ */
+public class ScheduledExecutorsExample {
+
+    public static void main(String[] args) {
+
+	try {
+	    ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+	    
+	    //print time with every second
+	    Runnable task = () -> {
+		System.out.println("Current date time: " + LocalDateTime.now());
+	    };
+	    
+	    executor.scheduleAtFixedRate(task,0, 1, TimeUnit.SECONDS);//0: initial delay, 1: period
+	    
+	} catch (Exception e) {
+	    e.printStackTrace();
+	}
+    }
+
+}

src/main/java/com/caysever/java8/concurrency/ScheduledFixedRateExecutorsExample.java

@@ -0,0 +1,43 @@
+package com.caysever.java8.concurrency;
+
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+import com.caysever.java8.model.Person;
+import com.caysever.java8.utils.PersonUtil;
+
+/**
+ * @author alican
+ *
+ */
+public class ScheduledFixedRateExecutorsExample {
+
+    public static void main(String[] args) {
+
+	try {
+	    List<Person> persons = PersonUtil.mockPersons();
+
+	    ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+	    
+	    Runnable task = () -> {
+		String threadName = Thread.currentThread().getName();// pool-1-thread-1
+		persons.forEach((p) -> System.out.println(threadName + " | " + p));
+	    };
+	    
+	    ScheduledFuture<?> future = executor.schedule(task, 3, TimeUnit.SECONDS);
+	    
+	    long remainingDelay = future.getDelay(TimeUnit.MILLISECONDS);
+	    System.out.printf("Remaining Delay: %sms", remainingDelay);//remaining time almost is 2.99 second
+	    System.out.println();
+	    
+	    executor.shutdown();
+	    
+	} catch (Exception e) {
+	    e.printStackTrace();
+	}
+    }
+
+}