Add reentrant lock livelock demo (#19)

Author: beatrichartz

README.md

@@ -60,6 +60,10 @@ Examples of concurrency problems you encountered in development are welcome to p
     - [Demo description](#demo-description-6)
     - [Problem statement](#problem-statement-6)
     - [Quickly run](#quickly-run-6)
+- [🍺 Livelock caused by reentrant locks](#-livelock-caused-by-reentrant-locks)
+    - [Demo description](#demo-description-7)
+    - [Problem statement](#problem-statement-7)
+    - [Quickly run](#quickly-run-7)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
@@ -206,3 +210,25 @@ Task thread deadlocked.
 ```bash
 mvn compile exec:java -Dexec.mainClass=com.oldratlee.fucking.concurrency.SymmetricLockDeadlockDemo
 ```
+
+## 🍺 Livelock caused by reentrant locks
+
+\# For a problem description, see the paragraph about livelocks [in this article](https://www.baeldung.com/cs/deadlock-livelock-starvation#livelock)
+
+Demo class [`ReentrantLockLivelockDemo`](src/main/java/com/oldratlee/fucking/concurrency/ReentrantLockLivelockDemo.java).
+
+### Demo description
+
+Two task threads are trying to acquire a lock that the other thread holds while holding their own lock.
+
+### Problem statement
+
+While the threads are releasing their own lock constantly, they are also re-locking it immediately, denying the other thread
+a chance to acquire both locks. Since both threads are not blocked from executing but blocked from doing meaningful work,
+this is a livelock.
+
+### Quickly run
+
+```bash
+mvn compile exec:java -Dexec.mainClass=com.oldratlee.fucking.concurrency.ReentrantLockLivelockDemo
+```

src/main/java/com/oldratlee/fucking/concurrency/ReentrantLockLivelockDemo.java

@@ -0,0 +1,82 @@
+package com.oldratlee.fucking.concurrency;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * @author Beat Richartz
+ */
+public class ReentrantLockLivelockDemo {
+    private static final Lock lock1 = new ReentrantLock();
+    private static final Lock lock2 = new ReentrantLock();
+
+    public static void main(String[] args) throws Exception {
+        Thread thread1 = new Thread(ReentrantLockLivelockDemo::concurrencyCheckTask1);
+        thread1.start();
+        Thread thread2 = new Thread(ReentrantLockLivelockDemo::concurrencyCheckTask2);
+        thread2.start();
+    }
+
+    @SuppressWarnings("InfiniteLoopStatement")
+    private static void concurrencyCheckTask1() {
+        System.out.println("Started concurrency check task 1");
+        int counter = 0;
+
+        while (counter++ < 10_000) {
+            try {
+                if (lock1.tryLock(50, TimeUnit.MILLISECONDS)) {
+                    System.out.println("Task 1 acquired lock 1");
+                    Thread.sleep(50);
+                    if (lock2.tryLock()) {
+                        System.out.println("Task 1 acquired lock 2");
+                    } else {
+                        System.out.println("Task 1 failed to acquire lock 2, releasing lock 1");
+                        lock1.unlock();
+                        continue;
+                    }
+                }
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                break;
+            }
+
+            break;
+        }
+
+        System.err.printf("Fuck! No meaningful work done in %s iterations of task 1.\n", counter);
+        lock2.unlock();
+        lock1.unlock();
+    }
+
+    @SuppressWarnings("InfiniteLoopStatement")
+    private static void concurrencyCheckTask2() {
+        System.out.println("Started concurrency check task 2");
+
+        int counter = 0;
+        while (counter++ < 10_000) {
+            try {
+                if (lock2.tryLock(50, TimeUnit.MILLISECONDS)) {
+                    System.out.println("Task 2 acquired lock 2");
+                    Thread.sleep(50);
+                    if (lock1.tryLock()) {
+                        System.out.println("Task 2 acquired lock 1");
+                    } else {
+                        System.out.println("Task 2 failed to acquire lock 1, releasing lock 2");
+                        lock2.unlock();
+                        continue;
+                    }
+                }
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                break;
+            }
+
+            break;
+        }
+
+        System.err.printf("Fuck! No meaningful work done in %s iterations of task 2.\n", counter);
+        lock2.unlock();
+        lock1.unlock();
+    }
+}