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-basic/.gitignore

@@ -0,0 +1,26 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+*.txt
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml

core-java-modules/core-java-concurrency-basic/README.md

@@ -0,0 +1,16 @@
+## Core Java Concurrency Basic
+
+This module contains articles about basic Java concurrency
+
+### Relevant Articles: 
+- [Guide To CompletableFuture](https://www.baeldung.com/java-completablefuture)
+- [A Guide to the Java ExecutorService](https://www.baeldung.com/java-executor-service-tutorial)
+- [Guide to java.util.concurrent.Future](https://www.baeldung.com/java-future)
+- [Overview of the java.util.concurrent](https://www.baeldung.com/java-util-concurrent)
+- [Implementing a Runnable vs Extending a Thread](https://www.baeldung.com/java-runnable-vs-extending-thread)
+- [How to Kill a Java Thread](https://www.baeldung.com/java-thread-stop)
+- [ExecutorService – Waiting for Threads to Finish](https://www.baeldung.com/java-executor-wait-for-threads)
+- [Runnable vs. Callable in Java](https://www.baeldung.com/java-runnable-callable)
+- [What is Thread-Safety and How to Achieve it?](https://www.baeldung.com/java-thread-safety)
+- [How to Start a Thread in Java](https://www.baeldung.com/java-start-thread)
+- [[Next -->]](/core-java-modules/core-java-concurrency-basic-2)

core-java-modules/core-java-concurrency-basic/pom.xml

@@ -0,0 +1,52 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    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>
+    <artifactId>core-java-concurrency-basic</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-concurrency-basic</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.jayway.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${avaitility.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-concurrency-basic</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <properties>
+        <!-- testing -->
+        <assertj.version>3.6.1</assertj.version>
+        <avaitility.version>1.7.0</avaitility.version>
+    </properties>
+
+</project>

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/Scheduledexecutorservice/ScheduledExecutorServiceDemo.java

@@ -0,0 +1,52 @@
+package com.baeldung.concurrent.Scheduledexecutorservice;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+
+public class ScheduledExecutorServiceDemo {
+
+	private void execute() {
+		ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
+		getTasksToRun().apply(executorService);
+		executorService.shutdown();
+	}
+
+	private void executeWithMultiThread() {
+		ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
+		getTasksToRun().apply(executorService);
+		executorService.shutdown();
+	}
+
+	private Function<ScheduledExecutorService, Void> getTasksToRun() {
+		return (executorService -> {
+			ScheduledFuture<?> scheduledFuture1 = executorService.schedule(() -> {
+				// Task
+			}, 1, TimeUnit.SECONDS);
+
+			ScheduledFuture<?> scheduledFuture2 = executorService.scheduleAtFixedRate(() -> {
+				// Task
+			}, 1, 10, TimeUnit.SECONDS);
+
+			ScheduledFuture<?> scheduledFuture3 = executorService.scheduleWithFixedDelay(() -> {
+				// Task
+			}, 1, 10, TimeUnit.SECONDS);
+
+			ScheduledFuture<String> scheduledFuture4 = executorService.schedule(() -> {
+				// Task
+				return "Hellow world";
+			}, 1, TimeUnit.SECONDS);
+			return null;
+		});
+	}
+
+	public static void main(String... args) {
+		ScheduledExecutorServiceDemo demo = new ScheduledExecutorServiceDemo();
+		demo.execute();
+		demo.executeWithMultiThread();
+	}
+
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/callable/FactorialTask.java

@@ -0,0 +1,30 @@
+package com.baeldung.concurrent.callable;
+
+
+import java.util.concurrent.Callable;
+
+public class FactorialTask implements Callable<Integer> {
+    int number;
+
+    public FactorialTask(int number) {
+        this.number = number;
+    }
+
+    public Integer call() throws InvalidParamaterException {
+        int fact=1;
+        if(number < 0)
+            throw new InvalidParamaterException("Number must be positive");
+
+        for(int count=number;count>1;count--){
+            fact=fact * count;
+        }
+
+        return fact;
+    }
+
+    private class InvalidParamaterException extends Exception {
+        public InvalidParamaterException(String message) {
+            super(message);
+        }
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierExample.java

@@ -0,0 +1,24 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import java.util.concurrent.CyclicBarrier;
+
+public class CyclicBarrierExample {
+
+    public void start() {
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> {
+            // Task
+            System.out.println("All previous tasks are completed");
+        });
+
+        Thread t1 = new Thread(new Task(cyclicBarrier), "T1");
+        Thread t2 = new Thread(new Task(cyclicBarrier), "T2");
+        Thread t3 = new Thread(new Task(cyclicBarrier), "T3");
+
+        if (!cyclicBarrier.isBroken()) {
+            t1.start();
+            t2.start();
+            t3.start();
+        }
+    }
+}
+

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/cyclicbarrier/Task.java

@@ -0,0 +1,24 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+
+public class Task implements Runnable {
+
+    private CyclicBarrier barrier;
+
+    public Task(CyclicBarrier barrier) {
+        this.barrier = barrier;
+    }
+
+    @Override
+    public void run() {
+        try {
+            System.out.println("Thread : " + Thread.currentThread().getName() + " is waiting");
+            barrier.await();
+            System.out.println("Thread : " + Thread.currentThread().getName() + " is released");
+        } catch (InterruptedException | BrokenBarrierException e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/executor/ExecutorDemo.java

@@ -0,0 +1,14 @@
+package com.baeldung.concurrent.executor;
+
+import java.util.concurrent.Executor;
+
+public class ExecutorDemo {
+
+	public void execute() {
+		Executor executor = new Invoker();
+		executor.execute(()->{
+			// task to be performed
+		});
+	}
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/executor/Invoker.java

@@ -0,0 +1,12 @@
+package com.baeldung.concurrent.executor;
+
+import java.util.concurrent.Executor;
+
+public class Invoker implements Executor {
+
+	@Override
+	public void execute(Runnable r) {
+		r.run();
+	}
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/executorservice/DelayedCallable.java

@@ -0,0 +1,39 @@
+package com.baeldung.concurrent.executorservice;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+
+public class DelayedCallable implements Callable<String> {
+    
+    private String name;
+    private long period;
+    private CountDownLatch latch;
+    
+    public DelayedCallable(String name, long period, CountDownLatch latch) {
+        this(name, period);
+        this.latch = latch;
+    }
+
+    public DelayedCallable(String name, long period) {
+        this.name = name;
+        this.period = period;
+    }
+
+    public String call() {
+
+        try {
+            Thread.sleep(period);
+            
+            if (latch != null) {
+                latch.countDown();
+            }
+            
+        } catch (InterruptedException ex) {
+            // handle exception
+            ex.printStackTrace();
+            Thread.currentThread().interrupt();
+        }
+
+        return name;
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/executorservice/ExecutorServiceDemo.java

@@ -0,0 +1,27 @@
+package com.baeldung.concurrent.executorservice;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public class ExecutorServiceDemo {
+
+    ExecutorService executor = Executors.newFixedThreadPool(10);
+
+    public void execute() {
+
+        executor.submit(() -> {
+            new Task();
+        });
+
+        executor.shutdown();
+        executor.shutdownNow();
+        try {
+            executor.awaitTermination(20l, TimeUnit.NANOSECONDS);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/executorservice/Task.java

@@ -0,0 +1,10 @@
+package com.baeldung.concurrent.executorservice;
+
+public class Task implements Runnable {
+
+	@Override
+	public void run() {
+		// task details
+	}
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/future/FactorialSquareCalculator.java

@@ -0,0 +1,26 @@
+package com.baeldung.concurrent.future;
+
+import java.util.concurrent.RecursiveTask;
+
+public class FactorialSquareCalculator extends RecursiveTask<Integer> {
+    private static final long serialVersionUID = 1L;
+
+    final private Integer n;
+
+    FactorialSquareCalculator(Integer n) {
+        this.n = n;
+    }
+
+    @Override
+    protected Integer compute() {
+        if (n <= 1) {
+            return n;
+        }
+
+        FactorialSquareCalculator calculator = new FactorialSquareCalculator(n - 1);
+
+        calculator.fork();
+
+        return n * n + calculator.join();
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/future/FutureDemo.java

@@ -0,0 +1,44 @@
+package com.baeldung.concurrent.future;
+
+import java.util.concurrent.ExecutionException;
+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;
+
+public class FutureDemo {
+
+    public String invoke() {
+
+        String str = null;
+
+        ExecutorService executorService = Executors.newFixedThreadPool(10);
+
+        Future<String> future = executorService.submit(() -> {
+            // Task
+            Thread.sleep(10000l);
+            return "Hellow world";
+        });
+
+        future.cancel(false);
+
+        try {
+            future.get(20, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e1) {
+            e1.printStackTrace();
+        }
+
+        if (future.isDone() && !future.isCancelled()) {
+            try {
+                str = future.get();
+            } catch (InterruptedException | ExecutionException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return str;
+
+    }
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/future/SquareCalculator.java

@@ -0,0 +1,20 @@
+package com.baeldung.concurrent.future;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+class SquareCalculator {
+
+    private final ExecutorService executor;
+
+    SquareCalculator(ExecutorService executor) {
+        this.executor = executor;
+    }
+
+    Future<Integer> calculate(Integer input) {
+        return executor.submit(() -> {
+            Thread.sleep(1000);
+            return input * input;
+        });
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/runnable/EventLoggingTask.java

@@ -0,0 +1,17 @@
+package com.baeldung.concurrent.runnable;
+
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class EventLoggingTask implements  Runnable{
+    private Logger logger = LoggerFactory.getLogger(EventLoggingTask.class);
+
+    @Override
+    public void run() {
+
+        String messge="Message read from the event queue";
+        logger.info("Message read from event queue is "+messge);
+
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/runnable/TaskRunner.java

@@ -0,0 +1,25 @@
+package com.baeldung.concurrent.runnable;
+
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class TaskRunner {
+
+    private static ExecutorService executorService;
+
+    public static void main(String[] args) {
+        executeTask();
+    }
+
+    private static void executeTask() {
+        executorService= Executors.newSingleThreadExecutor();
+
+        EventLoggingTask task = new EventLoggingTask();
+
+        Future future = executorService.submit(task);
+
+        executorService.shutdown();
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/semaphore/SemaPhoreDemo.java

@@ -0,0 +1,24 @@
+package com.baeldung.concurrent.semaphore;
+
+import java.util.concurrent.Semaphore;
+
+public class SemaPhoreDemo {
+
+	static Semaphore semaphore = new Semaphore(10);
+	
+	public void execute() throws InterruptedException {
+
+		System.out.println("Available permit : " + semaphore.availablePermits());
+		System.out.println("Number of threads waiting to acquire: " + semaphore.getQueueLength());
+
+		if (semaphore.tryAcquire()) {
+			try {		
+			// perform some critical operations
+			} finally {
+				semaphore.release();
+			}
+		}
+
+	}
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/stopping/ControlSubThread.java

@@ -0,0 +1,53 @@
+package com.baeldung.concurrent.stopping;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class ControlSubThread implements Runnable {
+
+    private Thread worker;
+    private int interval = 100;
+    private AtomicBoolean running = new AtomicBoolean(false);
+    private AtomicBoolean stopped = new AtomicBoolean(true);
+
+
+    public ControlSubThread(int sleepInterval) {
+        interval = sleepInterval;
+    }
+
+    public void start() {
+        worker = new Thread(this);
+        worker.start();
+    }
+
+    public void stop() {
+        running.set(false);
+    }
+
+    public void interrupt() {
+        running.set(false);
+        worker.interrupt();
+    }
+
+    boolean isRunning() {
+        return running.get();
+    }
+
+    boolean isStopped() {
+        return stopped.get();
+    }
+
+    public void run() {
+        running.set(true);
+        stopped.set(false);
+        while (running.get()) {
+            try {
+                Thread.sleep(interval);
+            } catch (InterruptedException e) {
+            	Thread.currentThread().interrupt();
+                System.out.println("Thread was interrupted, Failed to complete operation");
+	    }
+            // do something
+        }
+        stopped.set(true);
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadfactory/BaeldungThreadFactory.java

@@ -0,0 +1,23 @@
+package com.baeldung.concurrent.threadfactory;
+
+import java.util.concurrent.ThreadFactory;
+
+public class BaeldungThreadFactory implements ThreadFactory {
+
+    private int threadId;
+    private String name;
+
+    public BaeldungThreadFactory(String name) {
+        threadId = 1;
+        this.name = name;
+    }
+
+    @Override
+    public Thread newThread(Runnable r) {
+        Thread t = new Thread(r, name + "-Thread_" + threadId);
+        System.out.println("created new thread with id : " + threadId + " and name : " + t.getName());
+        threadId++;
+        return t;
+    }
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadfactory/Demo.java

@@ -0,0 +1,13 @@
+package com.baeldung.concurrent.threadfactory;
+
+public class Demo {
+
+	public void execute() {
+		BaeldungThreadFactory factory = new BaeldungThreadFactory("BaeldungThreadFactory");
+		for (int i = 0; i < 10; i++) {
+			Thread t = factory.newThread(new Task());
+			t.start();
+		}
+	}
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadfactory/Task.java

@@ -0,0 +1,10 @@
+package com.baeldung.concurrent.threadfactory;
+
+public class Task implements Runnable {
+
+    @Override
+    public void run() {
+        // task details
+    }
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadsafety/application/Application.java

@@ -0,0 +1,86 @@
+package com.baeldung.concurrent.threadsafety.application;
+
+import com.baeldung.concurrent.threadsafety.callables.AtomicCounterCallable;
+import com.baeldung.concurrent.threadsafety.mathutils.MathUtils;
+import com.baeldung.concurrent.threadsafety.callables.CounterCallable;
+import com.baeldung.concurrent.threadsafety.callables.ExtrinsicLockCounterCallable;
+import com.baeldung.concurrent.threadsafety.callables.MessageServiceCallable;
+import com.baeldung.concurrent.threadsafety.callables.ReentranReadWriteLockCounterCallable;
+import com.baeldung.concurrent.threadsafety.callables.ReentrantLockCounterCallable;
+import com.baeldung.concurrent.threadsafety.services.AtomicCounter;
+import com.baeldung.concurrent.threadsafety.services.Counter;
+import com.baeldung.concurrent.threadsafety.services.ExtrinsicLockCounter;
+import com.baeldung.concurrent.threadsafety.services.MessageService;
+import com.baeldung.concurrent.threadsafety.services.ReentrantLockCounter;
+import com.baeldung.concurrent.threadsafety.services.ReentrantReadWriteLockCounter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class Application {
+    
+    public static void main(String[] args) throws InterruptedException, ExecutionException {
+
+        new Thread(() -> {
+            System.out.println(MathUtils.factorial(10));
+        }).start();
+        new Thread(() -> {
+            System.out.println(MathUtils.factorial(5));
+        }).start();
+        
+        ExecutorService executorService = Executors.newFixedThreadPool(10);
+        MessageService messageService = new MessageService("Welcome to Baeldung!");
+        Future<String> future1 = (Future<String>) executorService.submit(new MessageServiceCallable(messageService));
+        Future<String> future2 = (Future<String>) executorService.submit(new MessageServiceCallable(messageService));
+        System.out.println(future1.get());
+        System.out.println(future2.get());
+        
+        Counter counter = new Counter();
+        Future<Integer> future3 = (Future<Integer>) executorService.submit(new CounterCallable(counter));
+        Future<Integer> future4 = (Future<Integer>) executorService.submit(new CounterCallable(counter));
+        System.out.println(future3.get());
+        System.out.println(future4.get());
+        
+        ExtrinsicLockCounter extrinsicLockCounter = new ExtrinsicLockCounter();
+        Future<Integer> future5 = (Future<Integer>) executorService.submit(new ExtrinsicLockCounterCallable(extrinsicLockCounter));
+        Future<Integer> future6 = (Future<Integer>) executorService.submit(new ExtrinsicLockCounterCallable(extrinsicLockCounter));
+        System.out.println(future5.get());
+        System.out.println(future6.get());
+        
+        ReentrantLockCounter reentrantLockCounter = new ReentrantLockCounter();
+        Future<Integer> future7 = (Future<Integer>) executorService.submit(new ReentrantLockCounterCallable(reentrantLockCounter));
+        Future<Integer> future8 = (Future<Integer>) executorService.submit(new ReentrantLockCounterCallable(reentrantLockCounter));
+        System.out.println(future7.get());
+        System.out.println(future8.get());
+        
+        ReentrantReadWriteLockCounter reentrantReadWriteLockCounter = new ReentrantReadWriteLockCounter();
+        Future<Integer> future9 = (Future<Integer>) executorService.submit(new ReentranReadWriteLockCounterCallable(reentrantReadWriteLockCounter));
+        Future<Integer> future10 = (Future<Integer>) executorService.submit(new ReentranReadWriteLockCounterCallable(reentrantReadWriteLockCounter));
+        System.out.println(future9.get());
+        System.out.println(future10.get());
+        
+        AtomicCounter atomicCounter = new AtomicCounter();
+        Future<Integer> future11 = (Future<Integer>) executorService.submit(new AtomicCounterCallable(atomicCounter));
+        Future<Integer> future12 = (Future<Integer>) executorService.submit(new AtomicCounterCallable(atomicCounter));
+        System.out.println(future11.get());
+        System.out.println(future12.get());
+        
+        Collection<Integer> syncCollection = Collections.synchronizedCollection(new ArrayList<>());
+        Thread thread11 = new Thread(() -> syncCollection.addAll(Arrays.asList(1, 2, 3, 4, 5, 6)));
+        Thread thread12 = new Thread(() -> syncCollection.addAll(Arrays.asList(1, 2, 3, 4, 5, 6)));
+        thread11.start();
+        thread12.start();
+        
+        Map<String,String> concurrentMap = new ConcurrentHashMap<>();
+        concurrentMap.put("1", "one");
+        concurrentMap.put("2", "two");
+        concurrentMap.put("3", "three");
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadsafety/callables/AtomicCounterCallable.java

@@ -0,0 +1,19 @@
+package com.baeldung.concurrent.threadsafety.callables;
+
+import com.baeldung.concurrent.threadsafety.services.AtomicCounter;
+import java.util.concurrent.Callable;
+
+public class AtomicCounterCallable implements Callable<Integer> {
+
+    private final AtomicCounter counter;
+    
+    public AtomicCounterCallable(AtomicCounter counter) {
+        this.counter = counter;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        counter.incrementCounter();
+        return counter.getCounter();
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadsafety/callables/CounterCallable.java

@@ -0,0 +1,19 @@
+package com.baeldung.concurrent.threadsafety.callables;
+
+import com.baeldung.concurrent.threadsafety.services.Counter;
+import java.util.concurrent.Callable;
+
+public class CounterCallable implements Callable<Integer> {
+
+    private final Counter counter;
+    
+    public CounterCallable(Counter counter) {
+        this.counter = counter;
+    }
+
+    @Override
+    public Integer call() throws Exception {
+        counter.incrementCounter();
+        return counter.getCounter();
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadsafety/callables/ExtrinsicLockCounterCallable.java

@@ -0,0 +1,19 @@
+package com.baeldung.concurrent.threadsafety.callables;
+
+import com.baeldung.concurrent.threadsafety.services.ExtrinsicLockCounter;
+import java.util.concurrent.Callable;
+
+public class ExtrinsicLockCounterCallable implements Callable<Integer> {
+
+    private final ExtrinsicLockCounter counter;
+    
+    public ExtrinsicLockCounterCallable(ExtrinsicLockCounter counter) {
+        this.counter = counter;
+    }
+    
+    @Override
+    public Integer call() throws Exception {
+        counter.incrementCounter();
+        return counter.getCounter();
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadsafety/callables/MessageServiceCallable.java

@@ -0,0 +1,19 @@
+package com.baeldung.concurrent.threadsafety.callables;
+
+import com.baeldung.concurrent.threadsafety.services.MessageService;
+import java.util.concurrent.Callable;
+
+public class MessageServiceCallable implements Callable<String> {
+    
+    private final MessageService messageService;
+    
+    public MessageServiceCallable(MessageService messageService) {
+        this.messageService = messageService;
+    
+    }
+    
+    @Override
+    public String call() {
+        return messageService.getMesssage();
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadsafety/callables/ReentranReadWriteLockCounterCallable.java

@@ -0,0 +1,20 @@
+package com.baeldung.concurrent.threadsafety.callables;
+
+import com.baeldung.concurrent.threadsafety.services.ReentrantReadWriteLockCounter;
+import java.util.concurrent.Callable;
+
+public class ReentranReadWriteLockCounterCallable implements Callable<Integer> {
+
+    private final ReentrantReadWriteLockCounter counter;
+
+    public ReentranReadWriteLockCounterCallable(ReentrantReadWriteLockCounter counter) {
+        this.counter = counter;
+    }
+    
+    @Override
+    public Integer call() throws Exception {
+        counter.incrementCounter();
+        return counter.getCounter();
+    }
+
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadsafety/callables/ReentrantLockCounterCallable.java

@@ -0,0 +1,19 @@
+package com.baeldung.concurrent.threadsafety.callables;
+
+import com.baeldung.concurrent.threadsafety.services.ReentrantLockCounter;
+import java.util.concurrent.Callable;
+
+public class ReentrantLockCounterCallable implements Callable<Integer> {
+
+    private final ReentrantLockCounter counter;
+    
+    public ReentrantLockCounterCallable(ReentrantLockCounter counter) {
+        this.counter = counter;
+    }
+    
+    @Override
+    public Integer call() throws Exception {
+        counter.incrementCounter();
+        return counter.getCounter();
+    }
+}

core-java-modules/core-java-concurrency-basic/src/main/java/com/baeldung/concurrent/threadsafety/mathutils/MathUtils.java

@@ -0,0 +1,14 @@
+package com.baeldung.concurrent.threadsafety.mathutils;
+
+import java.math.BigInteger;
+
+public class MathUtils {
+    
+    public static BigInteger factorial(int number) {
+        BigInteger f = new BigInteger("1");
+        for (int i = 2; i <= number; i++) {
+            f = f.multiply(BigInteger.valueOf(i));
+        }
+        return f;
+    }
+}