Merge branch 'master' of https://github.com/eugenp/tutorials into ABA_problem

core-java-modules/core-java-14/README.md

@@ -8,3 +8,4 @@ This module contains articles about Java 14.
 - [Java Text Blocks](https://www.baeldung.com/java-text-blocks)
 - [Pattern Matching for instanceof in Java 14](https://www.baeldung.com/java-pattern-matching-instanceof)
 - [Helpful NullPointerExceptions in Java 14](https://www.baeldung.com/java-14-nullpointerexception)
+- [Foreign Memory Access API in Java 14](https://www.baeldung.com/java-foreign-memory-access)

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/npe/HelpfulNullPointerException.java

@@ -1,4 +1,4 @@
-package com.baeldung.java14.helpfulnullpointerexceptions;
+package com.baeldung.java14.npe;
 
 public class HelpfulNullPointerException {
 

core-java-modules/core-java-14/src/main/java/com/baeldung/java14/record/Person.java

@@ -0,0 +1,22 @@
+package com.baeldung.java14.record;
+
+import java.util.Objects;
+
+public record Person (String name, String address) {
+	
+	public static String UNKWOWN_ADDRESS = "Unknown";
+	public static String UNNAMED = "Unnamed";
+
+	public Person {
+		Objects.requireNonNull(name);
+		Objects.requireNonNull(address);
+	}
+	
+	public Person(String name) {
+		this(name, UNKWOWN_ADDRESS);
+	}
+	
+	public static Person unnamed(String address) {
+		return new Person(UNNAMED, address);
+	}
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/foreign/api/ForeignMemoryUnitTest.java

@@ -0,0 +1,84 @@
+package com.baeldung.java14.foreign.api;
+
+import jdk.incubator.foreign.*;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+public class ForeignMemoryUnitTest {
+
+    @Test
+    public void whenAValueIsSet_thenAccessTheValue() {
+        long value = 10;
+        MemoryAddress memoryAddress =
+          MemorySegment.allocateNative(8).baseAddress();
+        VarHandle varHandle = MemoryHandles.varHandle(long.class,
+          ByteOrder.nativeOrder());
+        varHandle.set(memoryAddress, value);
+        assertThat(varHandle.get(memoryAddress), is(value));
+    }
+
+    @Test
+    public void whenMultipleValuesAreSet_thenAccessAll() {
+        VarHandle varHandle = MemoryHandles.varHandle(int.class,
+          ByteOrder.nativeOrder());
+
+        try(MemorySegment memorySegment =
+          MemorySegment.allocateNative(100)) {
+            MemoryAddress base = memorySegment.baseAddress();
+            for(int i=0; i<25; i++) {
+                varHandle.set(base.addOffset((i*4)), i);
+            }
+            for(int i=0; i<25; i++) {
+                assertThat(varHandle.get(base.addOffset((i*4))), is(i));
+            }
+        }
+    }
+
+    @Test
+    public void whenSetValuesWithMemoryLayout_thenTheyCanBeRetrieved() {
+        SequenceLayout sequenceLayout =
+          MemoryLayout.ofSequence(25,
+            MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder()));
+        VarHandle varHandle =
+          sequenceLayout.varHandle(long.class,
+            MemoryLayout.PathElement.sequenceElement());
+
+        try(MemorySegment memorySegment =
+          MemorySegment.allocateNative(sequenceLayout)) {
+            MemoryAddress base = memorySegment.baseAddress();
+            for(long i=0; i<sequenceLayout.elementCount().getAsLong(); i++) {
+                varHandle.set(base, i, i);
+            }
+            for(long i=0; i<sequenceLayout.elementCount().getAsLong(); i++) {
+                assertThat(varHandle.get(base, i), is(i));
+            }
+        }
+    }
+
+    @Test
+    public void whenSlicingMemorySegment_thenTheyCanBeAccessedIndividually() {
+        MemoryAddress memoryAddress =
+          MemorySegment.allocateNative(12).baseAddress();
+        MemoryAddress memoryAddress1 =
+          memoryAddress.segment().asSlice(0,4).baseAddress();
+        MemoryAddress memoryAddress2 =
+          memoryAddress.segment().asSlice(4,4).baseAddress();
+        MemoryAddress memoryAddress3 =
+          memoryAddress.segment().asSlice(8,4).baseAddress();
+
+        VarHandle intHandle =
+          MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
+        intHandle.set(memoryAddress1, Integer.MIN_VALUE);
+        intHandle.set(memoryAddress2, 0);
+        intHandle.set(memoryAddress3, Integer.MAX_VALUE);
+
+        assertThat(intHandle.get(memoryAddress1), is(Integer.MIN_VALUE));
+        assertThat(intHandle.get(memoryAddress2), is(0));
+        assertThat(intHandle.get(memoryAddress3), is(Integer.MAX_VALUE));
+    }
+}

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/npe/HelpfulNullPointerExceptionUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.java14.helpfulnullpointerexceptions;
+package com.baeldung.java14.npe;
 
 import org.junit.Test;
 

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/record/PersonTest.java

@@ -0,0 +1,150 @@
+package com.baeldung.java14.record;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class PersonTest {
+
+    @Test
+    public void givenSameNameAndAddress_whenEquals_thenPersonsEqual() {
+
+        String name = "John Doe";
+        String address = "100 Linda Ln.";
+
+        Person person1 = new Person(name, address);
+        Person person2 = new Person(name, address);
+
+        assertTrue(person1.equals(person2));
+    }
+    
+    @Test
+    public void givenDifferentObject_whenEquals_thenNotEqual() {
+
+        Person person = new Person("John Doe", "100 Linda Ln.");
+
+        assertFalse(person.equals(new Object()));
+    }
+
+    @Test
+    public void givenDifferentName_whenEquals_thenPersonsNotEqual() {
+    
+        String address = "100 Linda Ln.";
+    
+        Person person1 = new Person("Jane Doe", address);
+        Person person2 = new Person("John Doe", address);
+    
+        assertFalse(person1.equals(person2));
+    }
+    
+    @Test
+    public void givenDifferentAddress_whenEquals_thenPersonsNotEqual() {
+    
+        String name = "John Doe";
+    
+        Person person1 = new Person(name, "100 Linda Ln.");
+        Person person2 = new Person(name, "200 London Ave.");
+    
+        assertFalse(person1.equals(person2));
+    }
+
+    @Test
+    public void givenSameNameAndAddress_whenHashCode_thenPersonsEqual() {
+
+        String name = "John Doe";
+        String address = "100 Linda Ln.";
+
+        Person person1 = new Person(name, address);
+        Person person2 = new Person(name, address);
+
+        assertEquals(person1.hashCode(), person2.hashCode());
+    }
+    
+    @Test
+    public void givenDifferentObject_whenHashCode_thenNotEqual() {
+
+        Person person = new Person("John Doe", "100 Linda Ln.");
+
+        assertNotEquals(person.hashCode(), new Object().hashCode());
+    }
+
+    @Test
+    public void givenDifferentName_whenHashCode_thenPersonsNotEqual() {
+
+        String address = "100 Linda Ln.";
+
+        Person person1 = new Person("Jane Doe", address);
+        Person person2 = new Person("John Doe", address);
+
+        assertNotEquals(person1.hashCode(), person2.hashCode());
+    }
+
+    @Test
+    public void givenDifferentAddress_whenHashCode_thenPersonsNotEqual() {
+
+        String name = "John Doe";
+
+        Person person1 = new Person(name, "100 Linda Ln.");
+        Person person2 = new Person(name, "200 London Ave.");
+
+        assertNotEquals(person1.hashCode(), person2.hashCode());
+    }
+
+    @Test
+    public void givenValidNameAndAddress_whenGetNameAndAddress_thenExpectedValuesReturned() {
+
+        String name = "John Doe";
+        String address = "100 Linda Ln.";
+
+        Person person = new Person(name, address);
+
+        assertEquals(name, person.name());
+        assertEquals(address, person.address());
+    }
+
+    @Test
+    public void givenValidNameAndAddress_whenToString_thenCorrectStringReturned() {
+
+        String name = "John Doe";
+        String address = "100 Linda Ln.";
+
+        Person person = new Person(name, address);
+
+        assertEquals("Person[name=" + name + ", address=" + address + "]", person.toString());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenNullName_whenConstruct_thenErrorThrown() {
+        new Person(null, "100 Linda Ln.");
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenNullAddress_whenConstruct_thenErrorThrown() {
+        new Person("John Doe", null);
+    }
+
+    @Test
+    public void givenUnknownAddress_whenConstructing_thenAddressPopulated() {
+
+        String name = "John Doe";
+
+        Person person = new Person(name);
+
+        assertEquals(name, person.name());
+        assertEquals(Person.UNKWOWN_ADDRESS, person.address());
+    }
+
+    @Test
+    public void givenUnnamed_whenConstructingThroughFactory_thenNamePopulated() {
+
+        String address = "100 Linda Ln.";
+
+        Person person = Person.unnamed(address);
+
+        assertEquals(Person.UNNAMED, person.name());
+        assertEquals(address, person.address());
+    }
+}

core-java-modules/core-java-arrays-sorting/README.md

@@ -5,5 +5,5 @@ This module contains articles about sorting arrays in Java
 ### Relevant Articles: 
 - [Sorting Arrays in Java](https://www.baeldung.com/java-sorting-arrays)
 - [Checking If an Array Is Sorted in Java](https://www.baeldung.com/java-check-sorted-array)
-- [How to Reverse an Array in Java](http://www.baeldung.com/java-invert-array)
+- [How to Reverse an Array in Java](https://www.baeldung.com/java-invert-array)
 - [Arrays.sort vs Arrays.parallelSort](https://www.baeldung.com/java-arrays-sort-vs-parallelsort)

core-java-modules/core-java-collections-maps-3/README.md

@@ -5,4 +5,5 @@ This module contains articles about Map data structures in Java.
 ### Relevant Articles: 
 - [Java TreeMap vs HashMap](https://www.baeldung.com/java-treemap-vs-hashmap)
 - [Comparing Two HashMaps in Java](https://www.baeldung.com/java-compare-hashmaps)
+- [The Map.computeIfAbsent() Method](https://www.baeldung.com/java-map-computeifabsent)
 - More articles: [[<-- prev]](/core-java-modules/core-java-collections-maps-2)

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

@@ -4,4 +4,5 @@
 
 ### Relevant Articles: 
 - [Using a Mutex Object in Java](https://www.baeldung.com/java-mutex)
+- [Testing Multi-Threaded Code in Java](https://www.baeldung.com/java-testing-multithreaded)
 

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

@@ -15,6 +15,38 @@
         <version>0.0.1-SNAPSHOT</version>
         <relativePath>../../parent-java</relativePath>
     </parent>
+	
+	<dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.thread-weaver</groupId>
+            <artifactId>threadweaver</artifactId>
+            <version>0.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.tempus-fugit</groupId>
+            <artifactId>tempus-fugit</artifactId>
+            <version>1.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.multithreadedtc</groupId>
+            <artifactId>multithreadedtc</artifactId>
+            <version>1.01</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.openjdk.jcstress</groupId>
+            <artifactId>jcstress-core</artifactId>
+            <version>0.5</version>
+        </dependency>
+    </dependencies>
 
     <build>
         <finalName>core-java-concurrency-2</finalName>
@@ -24,6 +56,51 @@
                 <filtering>true</filtering>
             </resource>
         </resources>
+		
+		<plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.1</version>
+                <configuration>
+                    <compilerVersion>${javac.target}</compilerVersion>
+                    <source>${javac.target}</source>
+                    <target>${javac.target}</target>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>2.2</version>
+                <executions>
+                    <execution>
+                        <id>main</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <finalName>jcstress</finalName>
+                            <transformers>
+                                <transformer
+                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>org.openjdk.jcstress.Main</mainClass>
+                                </transformer>
+                                <transformer
+                                    implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
+                                    <resource>META-INF/TestList</resource>
+                                </transformer>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
     </build>
+    
+    <properties>
+        <javac.target>1.8</javac.target>
+    </properties>
 
 </project>

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterMultithreadedTCUnitTest.java

@@ -1,5 +1,6 @@
 package com.baeldung.concurrent;
 
+import org.junit.Ignore;
 import org.junit.Test;
 
 import edu.umd.cs.mtc.MultithreadedTestCase;
@@ -25,9 +26,10 @@ public class MyCounterMultithreadedTCUnitTest extends MultithreadedTestCase {
     @SuppressWarnings("deprecation")
     @Override
     public void finish() {
-        assertEquals(2, counter.getCount());
+    	assertEquals(2, counter.getCount());
     }
 
+    @Ignore
     @Test
     public void testCounter() throws Throwable {
         TestFramework.runManyTimes(new MyCounterMultithreadedTCUnitTest(), 1000);

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterSimpleUnitTest.java

@@ -6,6 +6,7 @@ import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
+import org.junit.Ignore;
 import org.junit.Test;
 
 public class MyCounterSimpleUnitTest {
@@ -18,7 +19,8 @@ public class MyCounterSimpleUnitTest {
         assertEquals(500, counter.getCount());
     }
 
-    // @Test
+    @Ignore
+    @Test
     public void testCounterWithConcurrency() throws InterruptedException {
         int numberOfThreads = 100;
         ExecutorService service = Executors.newFixedThreadPool(10);
@@ -34,7 +36,8 @@ public class MyCounterSimpleUnitTest {
         assertEquals(numberOfThreads, counter.getCount());
     }
 
-    // @Test
+    @Ignore
+    @Test
     public void testSummationWithConcurrencyAndWait() throws InterruptedException {
         int numberOfThreads = 2;
         ExecutorService service = Executors.newFixedThreadPool(10);

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterTempusFugitUnitTest.java

@@ -3,6 +3,7 @@ package com.baeldung.concurrent;
 import static org.junit.Assert.assertEquals;
 
 import org.junit.AfterClass;
+import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 
@@ -20,6 +21,7 @@ public class MyCounterTempusFugitUnitTest {
 
     private static MyCounter counter = new MyCounter();
 
+    @Ignore
     @Test
     @Concurrent(count = 2)
     @Repeating(repetition = 10)

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterThreadWeaverUnitTest.java

@@ -2,6 +2,7 @@ package com.baeldung.concurrent;
 
 import static org.junit.Assert.assertEquals;
 
+import org.junit.Ignore;
 import org.junit.Test;
 
 import com.google.testing.threadtester.AnnotatedTestRunner;
@@ -34,6 +35,7 @@ public class MyCounterThreadWeaverUnitTest {
         assertEquals(2, counter.getCount());
     }
 
+    @Ignore
     @Test
     public void testCounter() {
         new AnnotatedTestRunner().runTests(this.getClass(), MyCounter.class);

core-java-modules/core-java-concurrency-advanced-3/README.md

@@ -11,4 +11,5 @@ This module contains articles about advanced topics about multithreading with co
 - [Guide to Work Stealing in Java](https://www.baeldung.com/java-work-stealing)
 - [Asynchronous Programming in Java](https://www.baeldung.com/java-asynchronous-programming)
 - [Java Thread Deadlock and Livelock](https://www.baeldung.com/java-deadlock-livelock)
+- [Guide to AtomicStampedReference in Java](https://www.baeldung.com/java-atomicstampedreference)
 - [[<-- previous]](/core-java-modules/core-java-concurrency-advanced-2)

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/deadlockAndLivelock/DeadlockExample.java

@@ -0,0 +1,60 @@
+package com.baeldung.deadlockAndLivelock;
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class DeadlockExample {
+
+    private Lock lock1 = new ReentrantLock(true);
+    private Lock lock2 = new ReentrantLock(true);
+
+    public static void main(String[] args) {
+        DeadlockExample deadlock = new DeadlockExample();
+        new Thread(deadlock::operation1, "T1").start();
+        new Thread(deadlock::operation2, "T2").start();
+
+    }
+
+    public void operation1() {
+        lock1.lock();
+        print("lock1 acquired, waiting to acquire lock2.");
+        sleep(50);
+
+        lock2.lock();
+        print("lock2 acquired");
+
+        print("executing first operation.");
+
+        lock2.unlock();
+        lock1.unlock();
+
+    }
+
+    public void operation2() {
+        lock2.lock();
+        print("lock2 acquired, waiting to acquire lock1.");
+        sleep(50);
+
+        lock1.lock();
+        print("lock1 acquired");
+
+        print("executing second operation.");
+
+        lock1.unlock();
+        lock2.unlock();
+    }
+
+    public void print(String message) {
+        System.out.println("Thread " + Thread.currentThread()
+            .getName() + ": " + message);
+    }
+
+    public void sleep(long millis) {
+        try {
+            Thread.sleep(millis);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/deadlockAndLivelock/LivelockExample.java

@@ -0,0 +1,86 @@
+package com.baeldung.deadlockAndLivelock;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class LivelockExample {
+
+    private Lock lock1 = new ReentrantLock(true);
+    private Lock lock2 = new ReentrantLock(true);
+
+    public static void main(String[] args) {
+        LivelockExample livelock = new LivelockExample();
+        new Thread(livelock::operation1, "T1").start();
+        new Thread(livelock::operation2, "T2").start();
+
+    }
+
+    public void operation1() {
+        while (true) {
+            tryLock(lock1, 50);
+            print("lock1 acquired, trying to acquire lock2.");
+            sleep(50);
+
+            if (tryLock(lock2)) {
+                print("lock2 acquired.");
+            } else {
+                print("cannot acquire lock2, releasing lock1.");
+                lock1.unlock();
+                continue;
+            }
+
+            print("executing first operation.");
+            break;
+        }
+        lock2.unlock();
+        lock1.unlock();
+    }
+
+    public void operation2() {
+        while (true) {
+            tryLock(lock2, 50);
+            print("lock2 acquired, trying to acquire lock1.");
+            sleep(50);
+
+            if (tryLock(lock1)) {
+                print("lock1 acquired.");
+            } else {
+                print("cannot acquire lock1, releasing lock2.");
+                lock2.unlock();
+                continue;
+            }
+
+            print("executing second operation.");
+            break;
+        }
+        lock1.unlock();
+        lock2.unlock();
+    }
+
+    public void print(String message) {
+        System.out.println("Thread " + Thread.currentThread()
+            .getName() + ": " + message);
+    }
+
+    public void sleep(long millis) {
+        try {
+            Thread.sleep(millis);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void tryLock(Lock lock, long millis) {
+        try {
+            lock.tryLock(10, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public boolean tryLock(Lock lock) {
+        return lock.tryLock();
+    }
+
+}

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/lockfree/NonBlockingQueue.java

@@ -0,0 +1,81 @@
+package com.baeldung.lockfree;
+
+import java.util.NoSuchElementException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class NonBlockingQueue<T> {
+
+    private final AtomicReference<Node<T>> head, tail;
+    private final AtomicInteger size;
+
+    public NonBlockingQueue() {
+        head = new AtomicReference<>(null);
+        tail = new AtomicReference<>(null);
+        size = new AtomicInteger();
+        size.set(0);
+    }
+
+    public void add(T element) {
+        if (element == null) {
+            throw new NullPointerException();
+        }
+
+        Node<T> node = new Node<>(element);
+        Node<T> currentTail;
+        do {
+            currentTail = tail.get();
+            node.setPrevious(currentTail);
+        } while(!tail.compareAndSet(currentTail, node));
+
+        if(node.previous != null) {
+            node.previous.next = node;
+        }
+
+        head.compareAndSet(null, node); //if we are inserting the first element
+        size.incrementAndGet();
+    }
+
+    public T get() {
+        if(head.get() == null) {
+            throw new NoSuchElementException();
+        }
+
+        Node<T> currentHead;
+        Node<T> nextNode;
+        do {
+            currentHead = head.get();
+            nextNode = currentHead.getNext();
+        } while(!head.compareAndSet(currentHead, nextNode));
+
+        size.decrementAndGet();
+        return currentHead.getValue();
+    }
+
+    public int size() {
+        return this.size.get();
+    }
+
+    private class Node<T> {
+        private final T value;
+        private volatile Node<T> next;
+        private volatile Node<T> previous;
+
+        public Node(T value) {
+            this.value = value;
+            this.next = null;
+        }
+
+        public T getValue() {
+            return value;
+        }
+
+        public Node<T> getNext() {
+            return next;
+        }
+
+        public void setPrevious(Node<T> previous) {
+            this.previous = previous;
+        }
+    }
+}

core-java-modules/core-java-concurrency-advanced-3/src/test/java/com/baeldung/exchanger/ExchangerPipeLineManualTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.exchanger;
+
+import java.util.Queue;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.Exchanger;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+
+import static java.util.concurrent.CompletableFuture.runAsync;
+
+
+
+public class ExchangerPipeLineManualTest {
+
+    private static final int BUFFER_SIZE = 100;
+
+    @Test
+    public void givenData_whenPassedThrough_thenCorrect() throws InterruptedException, ExecutionException {
+
+        Exchanger<Queue<String>> readerExchanger = new Exchanger<>();
+        Exchanger<Queue<String>> writerExchanger = new Exchanger<>();
+        int counter = 0;
+
+        Runnable reader = () -> {
+            Queue<String> readerBuffer = new ConcurrentLinkedQueue<>();
+            while (true) {
+                readerBuffer.add(UUID.randomUUID().toString());
+                if (readerBuffer.size() >= BUFFER_SIZE) {
+                    try {
+                        readerBuffer = readerExchanger.exchange(readerBuffer);
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+        };
+
+        Runnable processor = () -> {
+            Queue<String> processorBuffer = new ConcurrentLinkedQueue<>();
+            Queue<String> writterBuffer = new ConcurrentLinkedQueue<>();
+            try {
+                processorBuffer = readerExchanger.exchange(processorBuffer);
+                while (true) {
+                    writterBuffer.add(processorBuffer.poll());
+                    if (processorBuffer.isEmpty()) {
+                        try {
+                            processorBuffer = readerExchanger.exchange(processorBuffer);
+                            writterBuffer = writerExchanger.exchange(writterBuffer);
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                            throw new RuntimeException(e);
+                        }
+                    }
+                }
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException(e);
+            }
+        };
+
+        Runnable writer = () -> {
+            Queue<String> writterBuffer = new ConcurrentLinkedQueue<>();
+            try {
+                writterBuffer = writerExchanger.exchange(writterBuffer);
+                while (true) {
+                    System.out.println(writterBuffer.poll());
+                    if (writterBuffer.isEmpty()) {
+                        writterBuffer = writerExchanger.exchange(writterBuffer);
+                    }
+                }
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException(e);
+            }
+        };
+
+        CompletableFuture.allOf(runAsync(reader), runAsync(processor), runAsync(writer)).get();
+    }
+
+}

core-java-modules/core-java-concurrency-advanced-3/src/test/java/com/baeldung/exchanger/ExchangerUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.exchanger;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Exchanger;
+
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+
+import static java.util.concurrent.CompletableFuture.runAsync;
+
+public class ExchangerUnitTest {
+    
+    
+    @Test
+    public void givenThreads_whenMessageExchanged_thenCorrect() {
+        Exchanger<String> exchanger = new Exchanger<>();
+
+        Runnable taskA = () -> {
+            try {
+                String message = exchanger.exchange("from A");
+                assertEquals("from B", message);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException(e);
+            }
+        };
+
+        Runnable taskB = () -> {
+            try {
+                String message = exchanger.exchange("from B");
+                assertEquals("from A", message);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException(e);
+            }
+        };
+
+        CompletableFuture.allOf(runAsync(taskA), runAsync(taskB)).join();
+    }
+
+    @Test
+    public void givenThread_WhenExchangedMessage_thenCorrect() throws InterruptedException, ExecutionException {
+        Exchanger<String> exchanger = new Exchanger<>();
+
+        Runnable runner = () -> {
+            try {
+                String message = exchanger.exchange("from runner");
+                assertEquals("to runner", message);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException(e);
+            }
+        };
+
+        CompletableFuture<Void> result = CompletableFuture.runAsync(runner);
+        String msg = exchanger.exchange("to runner");
+        assertEquals("from runner", msg);
+        result.join();
+    }
+
+}

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

@@ -1,7 +0,0 @@
-=========
-
-## Core Java Concurrency Testing Examples
-
-### Relevant Articles: 
-- [Testing Multi-Threaded Code in Java](https://www.baeldung.com/java-testing-multithreaded)
-

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

@@ -1,93 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<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-testing</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-    <name>core-java-concurrency-testing</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>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.13</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.googlecode.thread-weaver</groupId>
-            <artifactId>threadweaver</artifactId>
-            <version>0.2</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.google.code.tempus-fugit</groupId>
-            <artifactId>tempus-fugit</artifactId>
-            <version>1.1</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.googlecode.multithreadedtc</groupId>
-            <artifactId>multithreadedtc</artifactId>
-            <version>1.01</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.openjdk.jcstress</groupId>
-            <artifactId>jcstress-core</artifactId>
-            <version>0.5</version>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.1</version>
-                <configuration>
-                    <compilerVersion>${javac.target}</compilerVersion>
-                    <source>${javac.target}</source>
-                    <target>${javac.target}</target>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>2.2</version>
-                <executions>
-                    <execution>
-                        <id>main</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <finalName>jcstress</finalName>
-                            <transformers>
-                                <transformer
-                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <mainClass>org.openjdk.jcstress.Main</mainClass>
-                                </transformer>
-                                <transformer
-                                    implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
-                                    <resource>META-INF/TestList</resource>
-                                </transformer>
-                            </transformers>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-
-</project>

core-java-modules/core-java-concurrency-testing/src/main/resources/logback.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<configuration>
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
-            </pattern>
-        </encoder>
-    </appender>
-
-    <logger name="org.springframework" level="WARN" />
-    <logger name="org.springframework.transaction" level="WARN" />
-
-    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
-    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
-
-    <root level="INFO">
-        <appender-ref ref="STDOUT" />
-    </root>
-</configuration>

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

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

core-java-modules/core-java-date-operations-2/src/main/java/com/baeldung/weeknumber/WeekNumberUsingCalendar.java

@@ -0,0 +1,41 @@
+package com.baeldung.weeknumber;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
+public class WeekNumberUsingCalendar {
+
+    public int getWeekNumberFrom(String day, String dateFormat, Locale locale) throws ParseException {
+        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
+
+        Calendar calendar = Calendar.getInstance(locale);
+        Date date = sdf.parse(day);
+        calendar.setTime(date);
+
+        return calendar.get(Calendar.WEEK_OF_YEAR);
+    }
+
+    public int getWeekNumberFrom(int year, int month, int day, Locale locale) {
+        Calendar calendar = Calendar.getInstance(locale);
+        calendar.set(year, month, day);
+
+        return calendar.get(Calendar.WEEK_OF_YEAR);
+    }
+
+    public int getWeekNumberFrom(int year, int month, int day, int firstDayOfWeek, int minimalDaysInFirstWeek, Locale locale) {
+        Calendar calendar = Calendar.getInstance(locale);
+        calendar.setFirstDayOfWeek(firstDayOfWeek);
+        calendar.setMinimalDaysInFirstWeek(minimalDaysInFirstWeek);
+        calendar.set(year, month, day);
+
+        return calendar.get(Calendar.WEEK_OF_YEAR);
+    }
+
+    public static void main(String[] args) {
+        WeekNumberUsingCalendar calendar = new WeekNumberUsingCalendar();
+        System.out.println(calendar.getWeekNumberFrom(2020, 2, 22, Locale.CANADA));
+    }
+}

core-java-modules/core-java-date-operations-2/src/main/java/com/baeldung/weeknumber/WeekNumberUsingLocalDate.java

@@ -0,0 +1,30 @@
+package com.baeldung.weeknumber;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoField;
+import java.time.temporal.WeekFields;
+import java.util.Locale;
+
+public class WeekNumberUsingLocalDate {
+
+    public Integer getWeekNumberUsingWeekFiedsFrom(String day, String dayFormat, Locale locale) {
+        LocalDate date = LocalDate.parse(day, DateTimeFormatter.ofPattern(dayFormat));
+
+        return date.get(WeekFields.of(locale)
+            .weekOfYear());
+    }
+
+    public Integer getWeekNumberUsinWeekFieldsFrom(int year, int month, int day, Locale locale) {
+        LocalDate date = LocalDate.of(year, month, day);
+
+        return date.get(WeekFields.of(locale)
+            .weekOfYear());
+    }
+
+    public Integer getWeekNumberUsingChronoFieldFrom(int year, int month, int day) {
+        LocalDate date = LocalDate.of(year, month, day);
+
+        return date.get(ChronoField.ALIGNED_WEEK_OF_YEAR);
+    }
+}

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/weeknumber/WeekNumberUsingCalendarUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.weeknumber;
+
+import static org.junit.Assert.assertEquals;
+
+import java.text.ParseException;
+import java.util.Calendar;
+import java.util.Locale;
+
+import org.junit.Test;
+
+public class WeekNumberUsingCalendarUnitTest {
+    @Test
+    public void givenDateInStringAndDateFormatUsingLocaleItaly_thenGettingWeekNumberUsingCalendarIsCorrectlyReturned() throws ParseException {
+        WeekNumberUsingCalendar calendar = new WeekNumberUsingCalendar();
+
+        assertEquals(12, calendar.getWeekNumberFrom("20200322", "yyyyMMdd", Locale.ITALY));
+    }
+
+    @Test
+    public void givenDateInStringAndDateFormatUsingLocaleCanada_thenGettingWeekNumberUsingCalendarIsCorrectlyReturned() throws ParseException {
+        WeekNumberUsingCalendar calendar = new WeekNumberUsingCalendar();
+
+        assertEquals(13, calendar.getWeekNumberFrom("20200322", "yyyyMMdd", Locale.CANADA));
+    }
+
+    @Test
+    public void givenDateInYearMonthDayNumbersLocaleItaly_thenGettingWeekNumberUsingCalendarIsCorrectlyReturned() {
+        WeekNumberUsingCalendar calendar = new WeekNumberUsingCalendar();
+
+        assertEquals(12, calendar.getWeekNumberFrom(2020, 2, 22, Locale.ITALY));
+    }
+
+    @Test
+    public void givenDateInYearMonthDayNumbersLocaleItalyChangingWeekCalculationSettings_thenGettingWeekNumberUsingCalendarIsCorrectlyReturned() {
+        WeekNumberUsingCalendar calendar = new WeekNumberUsingCalendar();
+
+        assertEquals(13, calendar.getWeekNumberFrom(2020, 2, 22, Calendar.SUNDAY, 4, Locale.ITALY));
+    }
+
+    @Test
+    public void givenDateInYearMonthDayNumbersLocaleCanada_thenGettingWeekNumberUsingCalendarIsCorrectlyReturned() {
+        WeekNumberUsingCalendar calendar = new WeekNumberUsingCalendar();
+
+        assertEquals(13, calendar.getWeekNumberFrom(2020, 2, 22, Locale.CANADA));
+    }
+}

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/weeknumber/WeekNumberUsingLocalDateUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.weeknumber;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Locale;
+
+import org.junit.Test;
+
+public class WeekNumberUsingLocalDateUnitTest {
+    @Test
+    public void givenDateInStringAndDateFormatUsingWeekFieldsWithLocaleItaly_thenGettingWeekNumberUsingLocalDateIsCorrectlyReturned() {
+        WeekNumberUsingLocalDate localDate = new WeekNumberUsingLocalDate();
+
+        assertEquals(12, localDate.getWeekNumberUsingWeekFiedsFrom("20200322", "yyyyMMdd", Locale.ITALY)
+            .longValue());
+    }
+
+    @Test
+    public void givenDateInStringAndDateFormatUsingWeekFieldsWithLocaleCanada_thenGettingWeekNumberUsingLocalDateIsCorrectlyReturned() {
+        WeekNumberUsingLocalDate localDate = new WeekNumberUsingLocalDate();
+
+        assertEquals(13, localDate.getWeekNumberUsingWeekFiedsFrom("20200322", "yyyyMMdd", Locale.CANADA)
+            .longValue());
+    }
+
+    @Test
+    public void givenDateInStringAndDateFormatUsingChronoFieds_thenGettingWeekNumberUsingLocalDateIsCorrectlyReturned() {
+        WeekNumberUsingLocalDate localDate = new WeekNumberUsingLocalDate();
+
+        assertEquals(12, localDate.getWeekNumberUsingChronoFieldFrom(2020, 3, 22)
+            .longValue());
+    }
+
+    @Test
+    public void givenDateInYearMonthDayNumbersUsingWeekFieldsWithLocaleItaly_thenGettingWeekNumberUsingLocalDateIsCorrectlyReturned() {
+        WeekNumberUsingLocalDate localDate = new WeekNumberUsingLocalDate();
+
+        assertEquals(12, localDate.getWeekNumberUsinWeekFieldsFrom(2020, 3, 22, Locale.ITALY)
+            .longValue());
+    }
+
+    @Test
+    public void givenDateInYearMonthDayNumbersUsingWeekFieldsWithLocaleCanada_thenGettingWeekNumberUsingLocalDateIsCorrectlyReturned() {
+        WeekNumberUsingLocalDate localDate = new WeekNumberUsingLocalDate();
+
+        assertEquals(13, localDate.getWeekNumberUsinWeekFieldsFrom(2020, 3, 22, Locale.CANADA)
+            .longValue());
+    }
+}