From e6a664b0b60dabd4ca3f2d3a174f4d5038a45e49 Mon Sep 17 00:00:00 2001
From: Koziolek <bjkuczynski@gmail.com>
Date: Fri, 18 Oct 2024 19:35:35 +0200
Subject: [PATCH 1/2] feat: Replace synchronized by Lock in FutureImpl

---
 .../java/io/vavr/concurrent/FutureImpl.java   | 34 +++++++++++++++----
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/vavr/src/main/java/io/vavr/concurrent/FutureImpl.java b/vavr/src/main/java/io/vavr/concurrent/FutureImpl.java
index 57bd243ae..6f036abba 100644
--- a/vavr/src/main/java/io/vavr/concurrent/FutureImpl.java
+++ b/vavr/src/main/java/io/vavr/concurrent/FutureImpl.java
@@ -25,7 +25,9 @@
 
 import java.util.Objects;
 import java.util.concurrent.*;
+import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.LockSupport;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
 
 /**
@@ -45,7 +47,7 @@ final class FutureImpl<T> implements Future<T> {
     /**
      * Used to synchronize state changes.
      */
-    private final Object lock = new Object();
+    private final Lock lock = new ReentrantLock();
 
     /**
      * Indicates if this Future is cancelled
@@ -88,7 +90,8 @@ final class FutureImpl<T> implements Future<T> {
     // single constructor
     private FutureImpl(Executor executor, Option<Try<T>> value, Queue<Consumer<Try<T>>> actions, Queue<Thread> waiters, Computation<T> computation) {
         this.executor = executor;
-        synchronized (lock) {
+        lock.lock();
+        try {
             this.cancelled = false;
             this.value = value;
             this.actions = actions;
@@ -98,6 +101,8 @@ private FutureImpl(Executor executor, Option<Try<T>> value, Queue<Consumer<Try<T
             } catch (Throwable x) {
                 tryComplete(Try.failure(x));
             }
+        } finally {
+            lock.unlock();
         }
     }
 
@@ -219,8 +224,11 @@ private void _await(long start, long timeout, TimeUnit unit) {
                 public boolean block() {
                     try {
                         if (!threadEnqueued) {
-                            synchronized (lock) {
+                            lock.lock();
+                            try {
                                 waiters = waiters.enqueue(waitingThread);
+                            } finally {
+                                lock.unlock();
                             }
                             threadEnqueued = true;
                         }
@@ -256,7 +264,8 @@ public boolean isReleasable() {
     @Override
     public boolean cancel(boolean mayInterruptIfRunning) {
         if (!isCompleted()) {
-            synchronized (lock) {
+            lock.lock();
+            try {
                 if (!isCompleted()) {
                     if (mayInterruptIfRunning && this.thread != null) {
                         this.thread.interrupt();
@@ -264,6 +273,8 @@ public boolean cancel(boolean mayInterruptIfRunning) {
                     this.cancelled = tryComplete(Try.failure(new CancellationException()));
                     return this.cancelled;
                 }
+            } finally {
+                lock.unlock();
             }
         }
         return false;
@@ -272,7 +283,8 @@ public boolean cancel(boolean mayInterruptIfRunning) {
     private void updateThread() {
         // cancellation may have been initiated by a different thread before this.thread is set by the worker thread
         if (!isCompleted()) {
-            synchronized (lock) {
+            lock.lock();
+            try {
                 if (!isCompleted()) {
                     this.thread = Thread.currentThread();
                     try {
@@ -281,6 +293,8 @@ private void updateThread() {
                         // we are not allowed to set the uncaught exception handler of the worker thread ¯\_(ツ)_/¯
                     }
                 }
+            } finally {
+                lock.unlock();
             }
         }
     }
@@ -322,12 +336,15 @@ public Future<T> onComplete(Consumer<? super Try<T>> action) {
         if (isCompleted()) {
             perform(action);
         } else {
-            synchronized (lock) {
+            lock.lock();
+            try {
                 if (isCompleted()) {
                     perform(action);
                 } else {
                     actions = actions.enqueue((Consumer<Try<T>>) action);
                 }
+            } finally {
+                lock.unlock();
             }
         }
         return this;
@@ -362,7 +379,8 @@ boolean tryComplete(Try<? extends T> value) {
             final Queue<Consumer<Try<T>>> actions;
             final Queue<Thread> waiters;
             // it is essential to make the completed state public *before* performing the actions
-            synchronized (lock) {
+            lock.lock();
+            try {
                 if (isCompleted()) {
                     actions = null;
                     waiters = null;
@@ -374,6 +392,8 @@ boolean tryComplete(Try<? extends T> value) {
                     this.waiters = null;
                     this.thread = null;
                 }
+            } finally {
+                lock.unlock();
             }
             if (waiters != null) {
                 waiters.forEach(this::unlock);

From ec314afd99fdcfec65c5fe72076eeed2308bdc1b Mon Sep 17 00:00:00 2001
From: Koziolek <bjkuczynski@gmail.com>
Date: Fri, 18 Oct 2024 19:38:27 +0200
Subject: [PATCH 2/2] feat: move Lock initialization to constructor

---
 vavr/src/main/java/io/vavr/concurrent/FutureImpl.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/vavr/src/main/java/io/vavr/concurrent/FutureImpl.java b/vavr/src/main/java/io/vavr/concurrent/FutureImpl.java
index 6f036abba..f56b2458c 100644
--- a/vavr/src/main/java/io/vavr/concurrent/FutureImpl.java
+++ b/vavr/src/main/java/io/vavr/concurrent/FutureImpl.java
@@ -47,7 +47,7 @@ final class FutureImpl<T> implements Future<T> {
     /**
      * Used to synchronize state changes.
      */
-    private final Lock lock = new ReentrantLock();
+    private final Lock lock;
 
     /**
      * Indicates if this Future is cancelled
@@ -89,6 +89,7 @@ final class FutureImpl<T> implements Future<T> {
 
     // single constructor
     private FutureImpl(Executor executor, Option<Try<T>> value, Queue<Consumer<Try<T>>> actions, Queue<Thread> waiters, Computation<T> computation) {
+        this.lock = new ReentrantLock();
         this.executor = executor;
         lock.lock();
         try {