Merge branch 'master' into geroza/BAEL-9523_migrate-projects-to-paren-t-pom-2

akka-http/pom.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0"?>
+<project
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+	xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>akka-http</artifactId>
+	<name>akka-http</name>
+
+	<parent>
+		<artifactId>parent-modules</artifactId>
+		<groupId>com.baeldung</groupId>
+		<version>1.0.0-SNAPSHOT</version>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http_2.12</artifactId>
+			<version>${akka.http.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-stream_2.12</artifactId>
+			<version>2.5.11</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http-jackson_2.12</artifactId>
+			<version>${akka.http.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http-testkit_2.12</artifactId>
+			<version>${akka.http.version}</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+		<java.version>1.8</java.version>
+		<akka.http.version>10.0.11</akka.http.version>
+		<akka.stream.version>2.5.11</akka.stream.version>
+	</properties>
+</project>

akka-http/src/main/java/com/baeldung/akkahttp/User.java

@@ -0,0 +1,26 @@
+package com.baeldung.akkahttp;
+
+public class User {
+
+    private final Long id;
+
+    private final String name;
+
+    public User() {
+        this.name = "";
+        this.id = null;
+    }
+
+    public User(Long id, String name) {
+        this.name = name;
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserActor.java

@@ -0,0 +1,41 @@
+package com.baeldung.akkahttp;
+
+import akka.actor.AbstractActor;
+import akka.actor.Props;
+import akka.japi.pf.FI;
+import com.baeldung.akkahttp.UserMessages.ActionPerformed;
+import com.baeldung.akkahttp.UserMessages.CreateUserMessage;
+import com.baeldung.akkahttp.UserMessages.GetUserMessage;
+
+
+class UserActor extends AbstractActor {
+
+  private UserService userService = new UserService();
+
+  static Props props() {
+    return Props.create(UserActor.class);
+  }
+
+  @Override
+  public Receive createReceive() {
+    return receiveBuilder()
+            .match(CreateUserMessage.class, handleCreateUser())
+            .match(GetUserMessage.class, handleGetUser())
+            .build();
+  }
+
+  private FI.UnitApply<CreateUserMessage> handleCreateUser() {
+    return createUserMessageMessage -> {
+      userService.createUser(createUserMessageMessage.getUser());
+      sender().tell(new ActionPerformed(String.format("User %s created.", createUserMessageMessage.getUser()
+              .getName())), getSelf());
+    };
+  }
+
+  private FI.UnitApply<GetUserMessage> handleGetUser() {
+    return getUserMessageMessage -> {
+      sender().tell(userService.getUser(getUserMessageMessage.getUserId()), getSelf());
+    };
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserMessages.java

@@ -0,0 +1,49 @@
+package com.baeldung.akkahttp;
+
+import java.io.Serializable;
+
+public interface UserMessages {
+
+  class ActionPerformed implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final String description;
+
+    public ActionPerformed(String description) {
+      this.description = description;
+    }
+
+    public String getDescription() {
+      return description;
+    }
+  }
+
+  class CreateUserMessage implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+    private final User user;
+
+    public CreateUserMessage(User user) {
+      this.user = user;
+    }
+
+    public User getUser() {
+      return user;
+    }
+  }
+
+  class GetUserMessage implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private final Long userId;
+
+    public GetUserMessage(Long userId) {
+      this.userId = userId;
+    }
+
+    public Long getUserId() {
+      return userId;
+    }
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserServer.java

@@ -0,0 +1,70 @@
+package com.baeldung.akkahttp;
+
+import java.util.Optional;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.TimeUnit;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.http.javadsl.marshallers.jackson.Jackson;
+import akka.http.javadsl.model.StatusCodes;
+import akka.http.javadsl.server.HttpApp;
+import akka.http.javadsl.server.Route;
+import akka.pattern.PatternsCS;
+import akka.util.Timeout;
+import com.baeldung.akkahttp.UserMessages.ActionPerformed;
+import com.baeldung.akkahttp.UserMessages.CreateUserMessage;
+import com.baeldung.akkahttp.UserMessages.GetUserMessage;
+import scala.concurrent.duration.Duration;
+import static akka.http.javadsl.server.PathMatchers.*;
+
+class UserServer extends HttpApp {
+
+  private final ActorRef userActor;
+
+  Timeout timeout = new Timeout(Duration.create(5, TimeUnit.SECONDS));
+
+  UserServer(ActorRef userActor) {
+    this.userActor = userActor;
+  }
+
+  @Override
+  public Route routes() {
+    return path("users", this::postUser)
+            .orElse(path(segment("users").slash(longSegment()), id ->
+                    route(getUser(id))));
+  }
+
+  private Route getUser(Long id) {
+    return get(() -> {
+      CompletionStage<Optional<User>> user = PatternsCS.ask(userActor, new GetUserMessage(id), timeout)
+              .thenApply(obj -> (Optional<User>) obj);
+
+      return onSuccess(() -> user, performed -> {
+        if (performed.isPresent())
+          return complete(StatusCodes.OK, performed.get(), Jackson.marshaller());
+        else
+          return complete(StatusCodes.NOT_FOUND);
+      });
+    });
+  }
+
+  private Route postUser() {
+    return route(post(() -> entity(Jackson.unmarshaller(User.class), user -> {
+      CompletionStage<ActionPerformed> userCreated = PatternsCS.ask(userActor, new CreateUserMessage(user), timeout)
+              .thenApply(obj -> (ActionPerformed) obj);
+
+      return onSuccess(() -> userCreated, performed -> {
+        return complete(StatusCodes.CREATED, performed, Jackson.marshaller());
+      });
+    })));
+  }
+
+  public static void main(String[] args) throws Exception {
+    ActorSystem system = ActorSystem.create("userServer");
+    ActorRef userActor = system.actorOf(UserActor.props(), "userActor");
+    UserServer server = new UserServer(userActor);
+    server.startServer("localhost", 8080, system);
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserService.java

@@ -0,0 +1,35 @@
+package com.baeldung.akkahttp;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class UserService {
+
+  private final static List<User> users = new ArrayList<>();
+
+  static {
+    users.add(new User(1l, "Alice"));
+    users.add(new User(2l, "Bob"));
+    users.add(new User(3l, "Chris"));
+    users.add(new User(4l, "Dick"));
+    users.add(new User(5l, "Eve"));
+    users.add(new User(6l, "Finn"));
+  }
+
+  public Optional<User> getUser(Long id) {
+    return users.stream()
+            .filter(user -> user.getId()
+                    .equals(id))
+            .findFirst();
+  }
+
+  public void createUser(User user) {
+    users.add(user);
+  }
+
+  public List<User> getUsers(){
+    return users;
+  }
+
+}

akka-http/src/test/java/com/baeldung/akkahttp/UserServerUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.akkahttp;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.http.javadsl.model.ContentTypes;
+import akka.http.javadsl.model.HttpEntities;
+import akka.http.javadsl.model.HttpRequest;
+import akka.http.javadsl.testkit.JUnitRouteTest;
+import akka.http.javadsl.testkit.TestRoute;
+import org.junit.Test;
+
+public class UserServerUnitTest extends JUnitRouteTest {
+
+  ActorSystem system = ActorSystem.create("helloAkkaHttpServer");
+
+  ActorRef userActorRef = system.actorOf(UserActor.props(), "userActor");
+
+  TestRoute appRoute = testRoute(new UserServer(userActorRef).routes());
+
+  @Test
+  public void whenRequest_thenActorResponds() {
+
+    appRoute.run(HttpRequest.GET("/users/1"))
+            .assertEntity(alice())
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.GET("/users/42"))
+            .assertStatusCode(404);
+
+    appRoute.run(HttpRequest.DELETE("/users/1"))
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.DELETE("/users/42"))
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.POST("/users")
+            .withEntity(HttpEntities.create(ContentTypes.APPLICATION_JSON, zaphod())))
+            .assertStatusCode(201);
+
+  }
+
+  private String alice() {
+    return "{\"id\":1,\"name\":\"Alice\"}";
+  }
+
+  private String zaphod() {
+    return "{\"id\":42,\"name\":\"Zaphod\"}";
+  }
+
+}

algorithms-miscellaneous-1/README.md

@@ -10,4 +10,6 @@
 - [Multi-Swarm Optimization Algorithm in Java](http://www.baeldung.com/java-multi-swarm-algorithm)
 - [String Search Algorithms for Large Texts](http://www.baeldung.com/java-full-text-search-algorithms)
 - [Check If a String Contains All The Letters of The Alphabet](https://www.baeldung.com/java-string-contains-all-letters)
-- [Find the Middle Element of a Linked List](http://www.baeldung.com/java-linked-list-middle-element)
+- [Find the Middle Element of a Linked List](http://www.baeldung.com/java-linked-list-middle-element)
+- [Calculate Factorial in Java](https://www.baeldung.com/java-calculate-factorial)
+- [Find Substrings That Are Palindromes in Java](https://www.baeldung.com/java-palindrome-substrings)

apache-curator/pom.xml

@@ -59,7 +59,7 @@
     <properties>
         <curator.version>4.0.1</curator.version>
         <zookeeper.version>3.4.11</zookeeper.version>
-        <jackson-databind.version>2.9.4</jackson-databind.version>
+        <jackson-databind.version>2.9.7</jackson-databind.version>
         <!-- testing -->
         <assertj.version>3.6.1</assertj.version>
         <avaitility.version>1.7.0</avaitility.version>

core-java-8/src/main/java/com/baeldung/interfaces/Electronic.java

@@ -0,0 +1,22 @@
+package com.baeldung.interfaces;
+
+public interface Electronic {
+    //Constant variable
+    public static final String LED = "LED";
+
+    //Abstract method
+    public int getElectricityUse();
+
+    // Static method
+    public static boolean isEnergyEfficient(String electtronicType) {
+        if (electtronicType.equals(LED)) {
+            return true;
+        }
+        return false;
+    }
+
+    //Default method
+    public default void printDescription() {
+        System.out.println("Electronic Description");
+    }
+}

core-java-8/src/main/java/com/baeldung/interfaces/Employee.java

@@ -0,0 +1,15 @@
+package com.baeldung.interfaces;
+
+public class Employee {
+
+    private double salary;
+
+    public double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(double salary) {
+        this.salary = salary;
+    }
+
+}

core-java-8/src/main/java/com/baeldung/interfaces/EmployeeSalaryComparator.java

@@ -0,0 +1,18 @@
+package com.baeldung.interfaces;
+
+import java.util.Comparator;
+
+public class EmployeeSalaryComparator implements Comparator<Employee> {
+
+    @Override
+    public int compare(Employee employeeA, Employee employeeB) {
+
+        if(employeeA.getSalary() < employeeB.getSalary()){
+            return -1;
+        }else if(employeeA.getSalary() > employeeB.getSalary()){
+            return 1;
+        }else{
+            return 0;
+        }
+    }
+}

core-java-8/src/main/java/com/baeldung/interfaces/HasColor.java

@@ -0,0 +1,5 @@
+package com.baeldung.interfaces;
+
+public interface HasColor {
+    public String getColor();
+}

core-java-8/src/main/java/com/baeldung/interfaces/Motorcycle.java

@@ -0,0 +1,10 @@
+package com.baeldung.interfaces;
+
+import com.baeldung.interfaces.multiinheritance.Transform;
+
+public class Motorcycle implements Transform {
+    @Override
+    public void transform() {
+        // Implementation
+    }
+}

core-java-8/src/main/java/com/baeldung/interfaces/Truck.java

@@ -0,0 +1,8 @@
+package com.baeldung.interfaces;
+
+public class Truck extends Vehicle {
+    @Override
+    public void transform() {
+        // implementation
+    }
+}

core-java-8/src/main/java/com/baeldung/interfaces/Vehicle.java

@@ -0,0 +1,6 @@
+package com.baeldung.interfaces;
+
+import com.baeldung.interfaces.multiinheritance.Transform;
+
+public abstract class Vehicle implements Transform {
+}

core-java-8/src/main/java/com/baeldung/interfaces/multiinheritance/Car.java

@@ -0,0 +1,13 @@
+package com.baeldung.interfaces.multiinheritance;
+
+public class Car implements Fly, Transform {
+    @Override
+    public void fly() {
+        System.out.println("I can Fly!!");
+    }
+
+    @Override
+    public void transform() {
+        System.out.println("I can Transform!!");
+    }
+}

core-java-8/src/main/java/com/baeldung/interfaces/multiinheritance/Transform.java

@@ -1,5 +1,10 @@
 package com.baeldung.interfaces.multiinheritance;
 
 public interface Transform {
+
     void transform();
+
+    default void printSpecs(){
+        System.out.println("Transform Specification");
+    }
 }

core-java-8/src/main/java/com/baeldung/interfaces/polymorphysim/Circle.java

@@ -18,4 +18,8 @@ public class Circle implements Shape {
         return Math.PI * (radius * radius);
     }
 
+    @Override
+    public String getColor() {
+        return "green";
+    }
 }

core-java-8/src/main/java/com/baeldung/interfaces/polymorphysim/DisplayShape.java

@@ -6,6 +6,10 @@ public class DisplayShape {
 
     private ArrayList<Shape> shapes;
 
+    public ArrayList<Shape> getShapes() {
+        return shapes;
+    }
+
     public DisplayShape() {
         shapes = new ArrayList<>();
     }

core-java-8/src/main/java/com/baeldung/interfaces/polymorphysim/FunctionalMain.java

@@ -0,0 +1,23 @@
+package com.baeldung.interfaces.polymorphysim;
+
+import java.util.function.Predicate;
+
+public class FunctionalMain {
+
+public static void main(String[] args) {
+    Shape circleShape = new Circle(2);
+    Shape squareShape = new Square(2);
+
+    DisplayShape DisplayShape = new DisplayShape();
+    DisplayShape.add(circleShape);
+    DisplayShape.add(squareShape);
+
+    Predicate<Shape> checkArea = (shape) -> shape.area() < 5;
+
+    for (Shape shape : DisplayShape.getShapes()) {
+        if (checkArea.test(shape)) {
+            System.out.println(shape.name() + " " + shape.area());
+        }
+    }
+}
+}

core-java-8/src/main/java/com/baeldung/interfaces/polymorphysim/Shape.java

@@ -1,6 +1,9 @@
 package com.baeldung.interfaces.polymorphysim;
 
-public interface Shape {
+import com.baeldung.interfaces.HasColor;
+
+public interface Shape extends HasColor {
+
     public abstract String name();
     public abstract double area();
 }

core-java-8/src/main/java/com/baeldung/interfaces/polymorphysim/Square.java

@@ -17,4 +17,9 @@ public class Square implements Shape {
     public double area() {
         return width * width;
     }
+
+    @Override
+    public String getColor() {
+        return "red";
+    }
 }

core-java-collections/src/test/java/com/baeldung/hashmapvshashtable/HashmapVsHashtableDifferenceUnitTest.java

@@ -0,0 +1,98 @@
+package com.baeldung.hashmapvshashtable;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Collections;
+import java.util.ConcurrentModificationException;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+
+public class HashmapVsHashtableDifferenceUnitTest {
+
+    // null values
+    @Test(expected = NullPointerException.class)
+    public void givenHashtable_whenAddNullKey_thenNullPointerExceptionThrown() {
+        Hashtable<String, String> table = new Hashtable<String, String>();        
+        table.put(null, "value");
+    }
+    
+    @Test(expected = NullPointerException.class)
+    public void givenHashtable_whenAddNullValue_thenNullPointerExceptionThrown() {
+        Hashtable<String, String> table = new Hashtable<String, String>();        
+        table.put("key", null);
+    }
+    
+    @Test
+    public void givenHashmap_whenAddNullKeyAndValue_thenObjectAdded() {
+        HashMap<String, String> map = new HashMap<String, String>();
+        map.put(null, "value");
+        map.put("key1", null);
+        map.put("key2", null);
+        
+        assertEquals(3, map.size());
+    }
+    
+    // fail-fast iterator
+    @Test(expected = ConcurrentModificationException.class)
+    public void givenHashmap_whenModifyUnderlyingCollection_thenConcurrentModificationExceptionThrown() {
+        HashMap<String, String> map = new HashMap<String, String>();
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        map.put("key3", "value3");
+        
+        Iterator<String> iterator = map.keySet().iterator();
+        while(iterator.hasNext()){ 
+            iterator.next();
+            map.put("key4", "value4");
+        }        
+    }
+
+    @Test
+    public void givenHashtable_whenModifyUnderlyingCollection_thenItHasNoEffectOnIteratedCollection() {
+        Hashtable<String, String> table = new Hashtable<String, String>();        
+        table.put("key1", "value1");
+        table.put("key2", "value2");
+        
+        List<String> keysSelected = Lists.newArrayList(); 
+        Enumeration<String> keys = table.keys();
+        while (keys.hasMoreElements()) {
+            String key = keys.nextElement();
+            keysSelected.add(key);
+            
+            if (key.equals("key1")) {
+                table.put("key3", "value3");
+            }
+        }
+        
+        assertEquals(2, keysSelected.size());
+    }
+    
+    // synchronized map
+    @Test
+    public void givenHashmap_thenCreateSynchronizedMap() {
+        HashMap<String, String> map = new HashMap<String, String>();
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        map.put("key3", "value3");
+        
+        Set<Entry<String, String>> set = map.entrySet();
+        synchronized (map) {
+            Iterator<Entry<String, String>> it = set.iterator();
+            while(it.hasNext()) {
+                Map.Entry<String, String> elem = (Map.Entry<String, String>)it.next();
+             }            
+        }
+        
+        Map<String, String> syncMap = Collections.synchronizedMap(map);
+    }
+}

core-java-concurrency-advanced/README.md

@@ -1,33 +1,24 @@
 =========
 
-## Core Java Concurrency Examples
+## Core Java Concurrency Advanced Examples
 
 ### Relevant Articles: 
-- [Guide To CompletableFuture](http://www.baeldung.com/java-completablefuture)
-- [A Guide to the Java ExecutorService](http://www.baeldung.com/java-executor-service-tutorial)
 - [Introduction to Thread Pools in Java](http://www.baeldung.com/thread-pool-java-and-guava)
-- [Guide to java.util.concurrent.Future](http://www.baeldung.com/java-future)
 - [Guide to CountDownLatch in Java](http://www.baeldung.com/java-countdown-latch)
 - [Guide to java.util.concurrent.Locks](http://www.baeldung.com/java-concurrent-locks)
 - [An Introduction to ThreadLocal in Java](http://www.baeldung.com/java-threadlocal)
-- [Difference Between Wait and Sleep in Java](http://www.baeldung.com/java-wait-and-sleep)
 - [LongAdder and LongAccumulator in Java](http://www.baeldung.com/java-longadder-and-longaccumulator)
 - [The Dining Philosophers Problem in Java](http://www.baeldung.com/java-dining-philoshophers)
 - [Guide to the Java Phaser](http://www.baeldung.com/java-phaser)
-- [Guide to Synchronized Keyword in Java](http://www.baeldung.com/java-synchronized)
 - [An Introduction to Atomic Variables in Java](http://www.baeldung.com/java-atomic-variables)
 - [CyclicBarrier in Java](http://www.baeldung.com/java-cyclic-barrier)
 - [Guide to Volatile Keyword in Java](http://www.baeldung.com/java-volatile)
-- [Overview of the java.util.concurrent](http://www.baeldung.com/java-util-concurrent)
 - [Semaphores in Java](http://www.baeldung.com/java-semaphore)
 - [Daemon Threads in Java](http://www.baeldung.com/java-daemon-thread)
-- [Implementing a Runnable vs Extending a Thread](http://www.baeldung.com/java-runnable-vs-extending-thread)
-- [How to Kill a Java Thread](http://www.baeldung.com/java-thread-stop)
-- [ExecutorService - Waiting for Threads to Finish](http://www.baeldung.com/java-executor-wait-for-threads)
-- [wait and notify() Methods in Java](http://www.baeldung.com/java-wait-notify)
 - [Priority-based Job Scheduling in Java](http://www.baeldung.com/java-priority-job-schedule)
-- [Life Cycle of a Thread in Java](http://www.baeldung.com/java-thread-lifecycle)
-- [Runnable vs. Callable in Java](http://www.baeldung.com/java-runnable-callable)
 - [Brief Introduction to Java Thread.yield()](https://www.baeldung.com/java-thread-yield)
 - [Print Even and Odd Numbers Using 2 Threads](https://www.baeldung.com/java-even-odd-numbers-with-2-threads)
 - [Java CyclicBarrier vs CountDownLatch](https://www.baeldung.com/java-cyclicbarrier-countdownlatch)
+- [Guide to the Fork/Join Framework in Java](http://www.baeldung.com/java-fork-join)
+- [A Guide to ThreadLocalRandom in Java](http://www.baeldung.com/java-thread-local-random)
+- [The Thread.join() Method in Java](http://www.baeldung.com/java-thread-join)

core-java-concurrency-advanced/pom.xml

@@ -2,10 +2,10 @@
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.baeldung</groupId>
-    <artifactId>core-java-concurrency</artifactId>
+    <artifactId>core-java-concurrency-advanced</artifactId>
     <version>0.1.0-SNAPSHOT</version>
     <packaging>jar</packaging>
-    <name>core-java-concurrency</name>
+    <name>core-java-concurrency-advanced</name>
 
     <parent>
         <groupId>com.baeldung</groupId>
@@ -47,10 +47,20 @@
             <version>${avaitility.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-core</artifactId>
+            <version>${jmh-core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jmh</groupId>
+            <artifactId>jmh-generator-annprocess</artifactId>
+            <version>${jmh-generator-annprocess.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
-        <finalName>core-java-concurrency</finalName>
+        <finalName>core-java-concurrency-advanced</finalName>
         <resources>
             <resource>
                 <directory>src/main/resources</directory>
@@ -69,6 +79,8 @@
         <!-- testing -->
         <assertj.version>3.6.1</assertj.version>
         <avaitility.version>1.7.0</avaitility.version>
+        <jmh-core.version>1.19</jmh-core.version>
+        <jmh-generator-annprocess.version>1.19</jmh-generator-annprocess.version>
     </properties>
 
 </project>

core-java-concurrency-advanced/src/main/java/com/baeldung/concurrent/atomic/SafeCounterWithLock.java

@@ -1,13 +1,13 @@
-package com.baeldung.concurrent.atomic;
-
-public class SafeCounterWithLock {
-    private volatile int counter;
-    
-    int getValue() {
-        return counter;
-    }
-    
-    synchronized void increment() {
-        counter++;
-    }
-}
+package com.baeldung.concurrent.atomic;
+
+public class SafeCounterWithLock {
+    private volatile int counter;
+    
+    int getValue() {
+        return counter;
+    }
+    
+    synchronized void increment() {
+        counter++;
+    }
+}

core-java-concurrency-advanced/src/main/java/com/baeldung/concurrent/atomic/SafeCounterWithoutLock.java

@@ -1,21 +1,21 @@
-package com.baeldung.concurrent.atomic;
-
-import java.util.concurrent.atomic.AtomicInteger;
-
-public class SafeCounterWithoutLock {
-    private final AtomicInteger counter = new AtomicInteger(0);
-    
-    int getValue() {
-        return counter.get();
-    }
-    
-    void increment() {
-        while(true) {
-            int existingValue = getValue();
-            int newValue = existingValue + 1;
-            if(counter.compareAndSet(existingValue, newValue)) {
-                return;
-            }
-        }
-    }
-}
+package com.baeldung.concurrent.atomic;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class SafeCounterWithoutLock {
+    private final AtomicInteger counter = new AtomicInteger(0);
+    
+    int getValue() {
+        return counter.get();
+    }
+    
+    void increment() {
+        while(true) {
+            int existingValue = getValue();
+            int newValue = existingValue + 1;
+            if(counter.compareAndSet(existingValue, newValue)) {
+                return;
+            }
+        }
+    }
+}

core-java-concurrency-advanced/src/main/java/com/baeldung/concurrent/atomic/UnsafeCounter.java

@@ -1,13 +1,13 @@
-package com.baeldung.concurrent.atomic;
-
-public class UnsafeCounter {
-    private int counter;
-    
-    int getValue() {
-        return counter;
-    }
-    
-    void increment() {
-        counter++;
-    }
-}
+package com.baeldung.concurrent.atomic;
+
+public class UnsafeCounter {
+    private int counter;
+    
+    int getValue() {
+        return counter;
+    }
+    
+    void increment() {
+        counter++;
+    }
+}

core-java-concurrency-advanced/src/main/java/com/baeldung/concurrent/parameter/AverageCalculator.java

@@ -0,0 +1,20 @@
+package com.baeldung.concurrent.parameter;
+
+import java.util.concurrent.Callable;
+import java.util.stream.IntStream;
+
+public class AverageCalculator implements Callable<Double> {
+
+    int[] numbers;
+
+    public AverageCalculator(int... parameter) {
+        this.numbers = parameter == null ? new int[0] : parameter;
+    }
+
+    @Override
+    public Double call() throws Exception {
+        return IntStream.of(this.numbers)
+            .average()
+            .orElse(0d);
+    }
+}

core-java-concurrency-advanced/src/main/java/com/baeldung/concurrent/parameter/ParameterizedThreadExample.java

@@ -0,0 +1,32 @@
+package com.baeldung.concurrent.parameter;
+
+import java.util.concurrent.Callable;
+import java.util.stream.IntStream;
+
+public class ParameterizedThreadExample {
+
+    public static void parameterisedThreadAnonymousClass() {
+        final String parameter = "123";
+        Thread parameterizedThread = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                System.out.println(Thread.currentThread()
+                    .getName() + " : " + parameter);
+            }
+        });
+
+        parameterizedThread.start();
+    }
+
+    public static Callable<Integer> sumCalculator(int... numbers) {
+        return () -> numbers != null ? IntStream.of(numbers)
+            .sum() : 0;
+    }
+
+    public static Callable<Double> averageCalculator(int... numbers) {
+        return () -> numbers != null ? IntStream.of(numbers)
+            .average()
+            .orElse(0d) : 0d;
+    }
+}

core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/atomic/ThreadSafeCounterIntegrationTest.java

@@ -1,38 +1,38 @@
-package com.baeldung.concurrent.atomic;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.IntStream;
-
-import org.junit.Test;
-
-public class ThreadSafeCounterIntegrationTest {
-
-    @Test
-    public void givenMultiThread_whenSafeCounterWithLockIncrement() throws InterruptedException {
-        ExecutorService service = Executors.newFixedThreadPool(3);
-        SafeCounterWithLock safeCounter = new SafeCounterWithLock();
-
-        IntStream.range(0, 1000)
-          .forEach(count -> service.submit(safeCounter::increment));
-        service.awaitTermination(100, TimeUnit.MILLISECONDS);
-
-        assertEquals(1000, safeCounter.getValue());
-    }
-    
-    @Test
-    public void givenMultiThread_whenSafeCounterWithoutLockIncrement() throws InterruptedException {
-        ExecutorService service = Executors.newFixedThreadPool(3);
-        SafeCounterWithoutLock safeCounter = new SafeCounterWithoutLock();
-
-        IntStream.range(0, 1000)
-          .forEach(count -> service.submit(safeCounter::increment));
-        service.awaitTermination(100, TimeUnit.MILLISECONDS);
-
-        assertEquals(1000, safeCounter.getValue());
-    }
-    
-}
+package com.baeldung.concurrent.atomic;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+import org.junit.Test;
+
+public class ThreadSafeCounterIntegrationTest {
+
+    @Test
+    public void givenMultiThread_whenSafeCounterWithLockIncrement() throws InterruptedException {
+        ExecutorService service = Executors.newFixedThreadPool(3);
+        SafeCounterWithLock safeCounter = new SafeCounterWithLock();
+
+        IntStream.range(0, 1000)
+          .forEach(count -> service.submit(safeCounter::increment));
+        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+
+        assertEquals(1000, safeCounter.getValue());
+    }
+    
+    @Test
+    public void givenMultiThread_whenSafeCounterWithoutLockIncrement() throws InterruptedException {
+        ExecutorService service = Executors.newFixedThreadPool(3);
+        SafeCounterWithoutLock safeCounter = new SafeCounterWithoutLock();
+
+        IntStream.range(0, 1000)
+          .forEach(count -> service.submit(safeCounter::increment));
+        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+
+        assertEquals(1000, safeCounter.getValue());
+    }
+    
+}

core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/atomic/ThreadUnsafeCounterManualTest.java

@@ -1,33 +1,33 @@
-package com.baeldung.concurrent.atomic;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.IntStream;
-
-import org.junit.Test;
-
-/**
- * This test shows the behaviour of a thread-unsafe class in a multithreaded scenario. We are calling
- * the increment methods 1000 times from a pool of 3 threads. In most of the cases, the counter will 
- * less than 1000, because of lost updates, however, occasionally it may reach 1000, when no threads
- * called the method simultaneously. This may cause the build to fail occasionally. Hence excluding this
- * test from build by adding this in manual test
- */
-public class ThreadUnsafeCounterManualTest {
-
-    @Test
-    public void givenMultiThread_whenUnsafeCounterIncrement() throws InterruptedException {
-        ExecutorService service = Executors.newFixedThreadPool(3);
-        UnsafeCounter unsafeCounter = new UnsafeCounter();
-
-        IntStream.range(0, 1000)
-          .forEach(count -> service.submit(unsafeCounter::increment));
-        service.awaitTermination(100, TimeUnit.MILLISECONDS);
-
-        assertEquals(1000, unsafeCounter.getValue());
-    }
-    
-}
+package com.baeldung.concurrent.atomic;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+import org.junit.Test;
+
+/**
+ * This test shows the behaviour of a thread-unsafe class in a multithreaded scenario. We are calling
+ * the increment methods 1000 times from a pool of 3 threads. In most of the cases, the counter will 
+ * less than 1000, because of lost updates, however, occasionally it may reach 1000, when no threads
+ * called the method simultaneously. This may cause the build to fail occasionally. Hence excluding this
+ * test from build by adding this in manual test
+ */
+public class ThreadUnsafeCounterManualTest {
+
+    @Test
+    public void givenMultiThread_whenUnsafeCounterIncrement() throws InterruptedException {
+        ExecutorService service = Executors.newFixedThreadPool(3);
+        UnsafeCounter unsafeCounter = new UnsafeCounter();
+
+        IntStream.range(0, 1000)
+          .forEach(count -> service.submit(unsafeCounter::increment));
+        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+
+        assertEquals(1000, unsafeCounter.getValue());
+    }
+    
+}

core-java-concurrency-advanced/src/test/java/com/baeldung/parameters/ParameterizedThreadUnitTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.parameters;
+
+import com.baeldung.concurrent.parameter.AverageCalculator;
+import org.junit.Test;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.stream.IntStream;
+
+import static org.junit.Assert.assertEquals;
+
+public class ParameterizedThreadUnitTest {
+
+    @Test
+    public void whenSendingParameterToCallable_thenSuccessful() throws Exception {
+        ExecutorService executorService = Executors.newSingleThreadExecutor();
+        Future<Double> result = executorService.submit(new AverageCalculator(1, 2, 3));
+        try {
+            assertEquals(Double.valueOf(2.0), result.get());
+        } finally {
+            executorService.shutdown();
+        }
+    }
+
+    @Test
+    public void whenParametersToThreadWithLamda_thenParametersPassedCorrectly() throws Exception {
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+        int[] numbers = new int[] { 4, 5, 6 };
+        try {
+            Future<Integer> sumResult = executorService.submit(() -> IntStream.of(numbers)
+                .sum());
+            Future<Double> averageResult = executorService.submit(() -> IntStream.of(numbers)
+                .average()
+                .orElse(0d));
+            assertEquals(Integer.valueOf(15), sumResult.get());
+            assertEquals(Double.valueOf(5.0), averageResult.get());
+        } finally {
+            executorService.shutdown();
+        }
+    }
+
+}