Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/accumulator/LongAccumulatorUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.concurrent.accumulator;
+
+import org.junit.Test;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.LongAccumulator;
+import java.util.function.LongBinaryOperator;
+import java.util.stream.IntStream;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class LongAccumulatorUnitTest {
+
+    @Test
+    public void givenLongAccumulator_whenApplyActionOnItFromMultipleThrads_thenShouldProduceProperResult() throws InterruptedException {
+        // given
+        ExecutorService executorService = Executors.newFixedThreadPool(8);
+        LongBinaryOperator sum = Long::sum;
+        LongAccumulator accumulator = new LongAccumulator(sum, 0L);
+        int numberOfThreads = 4;
+        int numberOfIncrements = 100;
+
+        // when
+        Runnable accumulateAction = () -> IntStream.rangeClosed(0, numberOfIncrements).forEach(accumulator::accumulate);
+
+        for (int i = 0; i < numberOfThreads; i++) {
+            executorService.execute(accumulateAction);
+        }
+
+        // then
+        executorService.awaitTermination(500, TimeUnit.MILLISECONDS);
+        executorService.shutdown();
+        assertEquals(accumulator.get(), 20200);
+
+    }
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/adder/LongAdderUnitTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.concurrent.adder;
+
+import org.junit.Test;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.LongAdder;
+import java.util.stream.IntStream;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static junit.framework.TestCase.assertEquals;
+
+public class LongAdderUnitTest {
+    @Test
+    public void givenMultipleThread_whenTheyWriteToSharedLongAdder_thenShouldCalculateSumForThem() throws InterruptedException {
+        //given
+        LongAdder counter = new LongAdder();
+        ExecutorService executorService = Executors.newFixedThreadPool(8);
+
+        int numberOfThreads = 4;
+        int numberOfIncrements = 100;
+
+        //when
+        Runnable incrementAction = () -> IntStream
+          .range(0, numberOfIncrements)
+          .forEach((i) -> counter.increment());
+
+        for (int i = 0; i < numberOfThreads; i++) {
+            executorService.execute(incrementAction);
+        }
+
+        //then
+        executorService.awaitTermination(500, TimeUnit.MILLISECONDS);
+        executorService.shutdown();
+
+        assertEquals(counter.sum(), numberOfIncrements * numberOfThreads);
+        assertEquals(counter.sum(), numberOfIncrements * numberOfThreads);
+    }
+
+    @Test
+    public void givenMultipleThread_whenTheyWriteToSharedLongAdder_thenShouldCalculateSumForThemAndResetAdderAfterward() throws InterruptedException {
+        //given
+        LongAdder counter = new LongAdder();
+        ExecutorService executorService = Executors.newFixedThreadPool(8);
+
+        int numberOfThreads = 4;
+        int numberOfIncrements = 100;
+
+        //when
+        Runnable incrementAction = () -> IntStream
+          .range(0, numberOfIncrements)
+          .forEach((i) -> counter.increment());
+
+        for (int i = 0; i < numberOfThreads; i++) {
+            executorService.execute(incrementAction);
+        }
+
+        //then
+        executorService.awaitTermination(500, TimeUnit.MILLISECONDS);
+        executorService.shutdown();
+
+        assertEquals(counter.sumThenReset(), numberOfIncrements * numberOfThreads);
+
+        await().until(() -> assertEquals(counter.sum(), 0));
+    }
+}

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

@@ -0,0 +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());
+    }
+    
+}

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

@@ -0,0 +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());
+    }
+    
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchExampleIntegrationTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class CountdownLatchExampleIntegrationTest {
+    @Test
+    public void whenParallelProcessing_thenMainThreadWillBlockUntilCompletion() throws InterruptedException {
+        // Given
+        List<String> outputScraper = Collections.synchronizedList(new ArrayList<>());
+        CountDownLatch countDownLatch = new CountDownLatch(5);
+        List<Thread> workers = Stream.generate(() -> new Thread(new Worker(outputScraper, countDownLatch)))
+          .limit(5)
+          .collect(toList());
+
+        // When
+        workers.forEach(Thread::start);
+        countDownLatch.await(); // Block until workers finish
+        outputScraper.add("Latch released");
+
+        // Then
+        assertThat(outputScraper).containsExactly("Counted down", "Counted down", "Counted down", "Counted down", "Counted down", "Latch released");
+    }
+
+    @Test
+    public void whenFailingToParallelProcess_thenMainThreadShouldTimeout() throws InterruptedException {
+        // Given
+        List<String> outputScraper = Collections.synchronizedList(new ArrayList<>());
+        CountDownLatch countDownLatch = new CountDownLatch(5);
+        List<Thread> workers = Stream.generate(() -> new Thread(new BrokenWorker(outputScraper, countDownLatch)))
+          .limit(5)
+          .collect(toList());
+
+        // When
+        workers.forEach(Thread::start);
+        final boolean result = countDownLatch.await(3L, TimeUnit.SECONDS);
+
+        // Then
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void whenDoingLotsOfThreadsInParallel_thenStartThemAtTheSameTime() throws InterruptedException {
+        // Given
+        List<String> outputScraper = Collections.synchronizedList(new ArrayList<>());
+        CountDownLatch readyThreadCounter = new CountDownLatch(5);
+        CountDownLatch callingThreadBlocker = new CountDownLatch(1);
+        CountDownLatch completedThreadCounter = new CountDownLatch(5);
+        List<Thread> workers = Stream.generate(() -> new Thread(new WaitingWorker(outputScraper, readyThreadCounter, callingThreadBlocker, completedThreadCounter))).limit(5).collect(toList());
+
+        // When
+        workers.forEach(Thread::start);
+        readyThreadCounter.await(); // Block until workers start
+        outputScraper.add("Workers ready");
+        callingThreadBlocker.countDown(); // Start workers
+        completedThreadCounter.await(); // Block until workers finish
+        outputScraper.add("Workers complete");
+
+        // Then
+        assertThat(outputScraper).containsExactly("Workers ready", "Counted down", "Counted down", "Counted down", "Counted down", "Counted down", "Workers complete");
+    }
+
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierCompletionMethodExampleUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class CyclicBarrierCompletionMethodExampleUnitTest {
+    
+    @Test
+    public void whenCyclicBarrier_countTrips() {
+        CyclicBarrierCompletionMethodExample ex = new CyclicBarrierCompletionMethodExample(7,20);
+        int lineCount = ex.countTrips();
+        assertEquals(2, lineCount);
+    }
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/locks/SharedObjectWithLockManualTest.java

@@ -0,0 +1,73 @@
+package com.baeldung.concurrent.locks;
+
+import org.junit.Test;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class SharedObjectWithLockManualTest {
+
+    @Test
+    public void whenLockAcquired_ThenLockedIsTrue() {
+        final SharedObjectWithLock object = new SharedObjectWithLock();
+
+        final int threadCount = 2;
+        final ExecutorService service = Executors.newFixedThreadPool(threadCount);
+
+        executeThreads(object, threadCount, service);
+
+        assertEquals(true, object.isLocked());
+
+        service.shutdown();
+    }
+
+    @Test
+    public void whenLocked_ThenQueuedThread() {
+        final int threadCount = 4;
+        final ExecutorService service = Executors.newFixedThreadPool(threadCount);
+        final SharedObjectWithLock object = new SharedObjectWithLock();
+
+        executeThreads(object, threadCount, service);
+
+        assertEquals(object.hasQueuedThreads(), true);
+
+        service.shutdown();
+
+    }
+
+    public void whenTryLock_ThenQueuedThread() {
+        final SharedObjectWithLock object = new SharedObjectWithLock();
+
+        final int threadCount = 2;
+        final ExecutorService service = Executors.newFixedThreadPool(threadCount);
+
+        executeThreads(object, threadCount, service);
+
+        assertEquals(true, object.isLocked());
+
+        service.shutdown();
+    }
+
+    @Test
+    public void whenGetCount_ThenCorrectCount() throws InterruptedException {
+        final int threadCount = 4;
+        final ExecutorService service = Executors.newFixedThreadPool(threadCount);
+        final SharedObjectWithLock object = new SharedObjectWithLock();
+
+        executeThreads(object, threadCount, service);
+        Thread.sleep(1000);
+        assertEquals(object.getCounter(), 4);
+
+        service.shutdown();
+
+    }
+
+    private void executeThreads(SharedObjectWithLock object, int threadCount, ExecutorService service) {
+        for (int i = 0; i < threadCount; i++) {
+            service.execute(object::perform);
+        }
+    }
+
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/locks/SynchronizedHashMapWithRWLockManualTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.concurrent.locks;
+
+import org.junit.Test;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class SynchronizedHashMapWithRWLockManualTest {
+
+    @Test
+    public void whenWriting_ThenNoReading() {
+        SynchronizedHashMapWithRWLock object = new SynchronizedHashMapWithRWLock();
+        final int threadCount = 3;
+        final ExecutorService service = Executors.newFixedThreadPool(threadCount);
+
+        executeWriterThreads(object, threadCount, service);
+
+        assertEquals(object.isReadLockAvailable(), false);
+
+        service.shutdown();
+    }
+
+    @Test
+    public void whenReading_ThenMultipleReadingAllowed() {
+        SynchronizedHashMapWithRWLock object = new SynchronizedHashMapWithRWLock();
+        final int threadCount = 5;
+        final ExecutorService service = Executors.newFixedThreadPool(threadCount);
+
+        executeReaderThreads(object, threadCount, service);
+
+        assertEquals(object.isReadLockAvailable(), true);
+
+        service.shutdown();
+    }
+
+    private void executeWriterThreads(SynchronizedHashMapWithRWLock object, int threadCount, ExecutorService service) {
+        for (int i = 0; i < threadCount; i++) {
+            service.execute(() -> {
+                try {
+                    object.put("key" + threadCount, "value" + threadCount);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            });
+        }
+    }
+
+    private void executeReaderThreads(SynchronizedHashMapWithRWLock object, int threadCount, ExecutorService service) {
+        for (int i = 0; i < threadCount; i++)
+            service.execute(() -> object.get("key" + threadCount));
+    }
+
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/phaser/PhaserUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.concurrent.phaser;
+
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Phaser;
+
+import static junit.framework.TestCase.assertEquals;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class PhaserUnitTest {
+
+    @Test
+    public void givenPhaser_whenCoordinateWorksBetweenThreads_thenShouldCoordinateBetweenMultiplePhases() {
+        //given
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        Phaser ph = new Phaser(1);
+        assertEquals(0, ph.getPhase());
+
+        //when
+        executorService.submit(new LongRunningAction("thread-1", ph));
+        executorService.submit(new LongRunningAction("thread-2", ph));
+        executorService.submit(new LongRunningAction("thread-3", ph));
+
+        //then
+        ph.arriveAndAwaitAdvance();
+        assertEquals(1, ph.getPhase());
+
+        //and
+        executorService.submit(new LongRunningAction("thread-4", ph));
+        executorService.submit(new LongRunningAction("thread-5", ph));
+        ph.arriveAndAwaitAdvance();
+        assertEquals(2, ph.getPhase());
+
+
+        ph.arriveAndDeregister();
+    }
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/concurrent/volatilekeyword/SharedObjectManualTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.concurrent.volatilekeyword;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class SharedObjectManualTest {
+
+    @Test
+    public void whenOneThreadWrites_thenVolatileReadsFromMainMemory() throws InterruptedException {
+        SharedObject sharedObject = new SharedObject();
+
+        Thread writer = new Thread(() -> sharedObject.increamentCount());
+        writer.start();
+        Thread.sleep(100);
+
+        Thread readerOne = new Thread(() -> {
+            int valueReadByThread2 = sharedObject.getCount();
+            assertEquals(1, valueReadByThread2);
+        });
+        readerOne.start();
+
+        Thread readerTwo = new Thread(() -> {
+            int valueReadByThread3 = sharedObject.getCount();
+            assertEquals(1, valueReadByThread3);
+        });
+        readerTwo.start();
+
+    }
+
+    @Test
+    public void whenTwoThreadWrites_thenVolatileReadsFromMainMemory() throws InterruptedException {
+        SharedObject sharedObject = new SharedObject();
+        Thread writerOne = new Thread(() -> sharedObject.increamentCount());
+        writerOne.start();
+        Thread.sleep(100);
+
+        Thread writerTwo = new Thread(() -> sharedObject.increamentCount());
+        writerTwo.start();
+        Thread.sleep(100);
+
+        Thread readerOne = new Thread(() -> {
+            int valueReadByThread2 = sharedObject.getCount();
+            assertEquals(2, valueReadByThread2);
+        });
+        readerOne.start();
+
+        Thread readerTwo = new Thread(() -> {
+            int valueReadByThread3 = sharedObject.getCount();
+            assertEquals(2, valueReadByThread3);
+        });
+        readerTwo.start();
+
+    }
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/threadlocal/ThreadLocalIntegrationTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.threadlocal;
+
+
+import org.junit.Test;
+
+import java.util.concurrent.ExecutionException;
+
+import static org.junit.Assert.assertEquals;
+
+public class ThreadLocalIntegrationTest {
+    @Test
+    public void givenThreadThatStoresContextInAMap_whenStartThread_thenShouldSetContextForBothUsers() throws ExecutionException, InterruptedException {
+        //when
+        SharedMapWithUserContext firstUser = new SharedMapWithUserContext(1);
+        SharedMapWithUserContext secondUser = new SharedMapWithUserContext(2);
+        new Thread(firstUser).start();
+        new Thread(secondUser).start();
+
+        Thread.sleep(3000);
+        //then
+        assertEquals(SharedMapWithUserContext.userContextPerUserId.size(), 2);
+    }
+
+    @Test
+    public void givenThreadThatStoresContextInThreadLocal_whenStartThread_thenShouldStoreContextInThreadLocal() throws ExecutionException, InterruptedException {
+        //when
+        ThreadLocalWithUserContext firstUser = new ThreadLocalWithUserContext(1);
+        ThreadLocalWithUserContext secondUser = new ThreadLocalWithUserContext(2);
+        new Thread(firstUser).start();
+        new Thread(secondUser).start();
+
+        Thread.sleep(3000);
+    }
+
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/threadpool/CoreThreadPoolIntegrationTest.java

@@ -0,0 +1,147 @@
+package com.baeldung.threadpool;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.Assert.assertEquals;
+
+public class CoreThreadPoolIntegrationTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(CoreThreadPoolIntegrationTest.class);
+
+    @Test(timeout = 1000)
+    public void whenCallingExecuteWithRunnable_thenRunnableIsExecuted() throws InterruptedException {
+
+        CountDownLatch lock = new CountDownLatch(1);
+
+        Executor executor = Executors.newSingleThreadExecutor();
+        executor.execute(() -> {
+            LOG.debug("Hello World");
+            lock.countDown();
+        });
+
+        lock.await(1000, TimeUnit.MILLISECONDS);
+    }
+
+    @Test
+    public void whenUsingExecutorServiceAndFuture_thenCanWaitOnFutureResult() throws InterruptedException, ExecutionException {
+
+        ExecutorService executorService = Executors.newFixedThreadPool(10);
+        Future<String> future = executorService.submit(() -> "Hello World");
+        String result = future.get();
+
+        assertEquals("Hello World", result);
+
+    }
+
+    @Test
+    public void whenUsingFixedThreadPool_thenCoreAndMaximumThreadSizeAreTheSame() {
+
+        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+
+        assertEquals(2, executor.getPoolSize());
+        assertEquals(1, executor.getQueue().size());
+
+    }
+
+    @Test
+    public void whenUsingCachedThreadPool_thenPoolSizeGrowsUnbounded() {
+        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+        executor.submit(() -> {
+            Thread.sleep(1000);
+            return null;
+        });
+
+        assertEquals(3, executor.getPoolSize());
+        assertEquals(0, executor.getQueue().size());
+
+    }
+
+    @Test(timeout = 1000)
+    public void whenUsingSingleThreadPool_thenTasksExecuteSequentially() throws InterruptedException {
+
+        CountDownLatch lock = new CountDownLatch(2);
+        AtomicInteger counter = new AtomicInteger();
+
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        executor.submit(() -> {
+            counter.set(1);
+            lock.countDown();
+        });
+        executor.submit(() -> {
+            counter.compareAndSet(1, 2);
+            lock.countDown();
+        });
+
+        lock.await(1000, TimeUnit.MILLISECONDS);
+        assertEquals(2, counter.get());
+
+    }
+
+    @Test(timeout = 1000)
+    public void whenSchedulingTask_thenTaskExecutesWithinGivenPeriod() throws InterruptedException {
+
+        CountDownLatch lock = new CountDownLatch(1);
+
+        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
+        executor.schedule(() -> {
+            LOG.debug("Hello World");
+            lock.countDown();
+        }, 500, TimeUnit.MILLISECONDS);
+
+        lock.await(1000, TimeUnit.MILLISECONDS);
+
+    }
+
+    @Test(timeout = 1000)
+    public void whenSchedulingTaskWithFixedPeriod_thenTaskExecutesMultipleTimes() throws InterruptedException {
+
+        CountDownLatch lock = new CountDownLatch(3);
+
+        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
+        ScheduledFuture<?> future = executor.scheduleAtFixedRate(() -> {
+            LOG.debug("Hello World");
+            lock.countDown();
+        }, 500, 100, TimeUnit.MILLISECONDS);
+
+        lock.await();
+        future.cancel(true);
+
+    }
+
+    @Test
+    public void whenUsingForkJoinPool_thenSumOfTreeElementsIsCalculatedCorrectly() {
+
+        TreeNode tree = new TreeNode(5, new TreeNode(3), new TreeNode(2, new TreeNode(2), new TreeNode(8)));
+
+        ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();
+        int sum = forkJoinPool.invoke(new CountingTask(tree));
+
+        assertEquals(20, sum);
+    }
+
+}

core-java-modules/core-java-concurrency-advanced/src/test/java/com/baeldung/threadpool/GuavaThreadPoolIntegrationTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.threadpool;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class GuavaThreadPoolIntegrationTest {
+
+    @Test
+    public void whenExecutingTaskWithDirectExecutor_thenTheTaskIsExecutedInTheCurrentThread() {
+
+        Executor executor = MoreExecutors.directExecutor();
+
+        AtomicBoolean executed = new AtomicBoolean();
+
+        executor.execute(() -> {
+            try {
+                Thread.sleep(500);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            executed.set(true);
+        });
+
+        assertTrue(executed.get());
+    }
+
+    @Test
+    public void whenJoiningFuturesWithAllAsList_thenCombinedFutureCompletesAfterAllFuturesComplete() throws ExecutionException, InterruptedException {
+
+        ExecutorService executorService = Executors.newCachedThreadPool();
+        ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(executorService);
+
+        ListenableFuture<String> future1 = listeningExecutorService.submit(() -> "Hello");
+        ListenableFuture<String> future2 = listeningExecutorService.submit(() -> "World");
+
+        String greeting = Futures.allAsList(future1, future2).get().stream().collect(Collectors.joining(" "));
+        assertEquals("Hello World", greeting);
+
+    }
+
+}

core-java-modules/core-java-concurrency-advanced/src/test/resources/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear