Use ReentrantLock i.o. Thread#yield

Use ReentrantLock i.o. Thread#yield. This should provide a more
efficient process for dealing with the request stream. We've seen some
users hit high CPU load specifically on the yield operation, which may
occur when a large number of query updates are passed along from one
application.

#enhancement/reentrant-lock-io-yield

src/main/java/io/axoniq/axonserver/connector/impl/SynchronizedRequestStream.java

@@ -19,6 +19,7 @@
 import io.grpc.stub.ClientCallStreamObserver;
 
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * Lock-based synchronized implementation of a {@link ClientCallStreamObserver}. Acts as a wrapper of another {@code
@@ -30,7 +31,7 @@
 public class SynchronizedRequestStream<T> extends ClientCallStreamObserver<T> {
 
     private final ClientCallStreamObserver<T> delegate;
-    private final AtomicBoolean lock = new AtomicBoolean(false);
+    private final ReentrantLock lock = new ReentrantLock();
     private final AtomicBoolean halfClosed = new AtomicBoolean(false);
 
     /**
@@ -100,15 +101,13 @@ public void onCompleted() {
     }
 
     private void inLock(Runnable action) {
-        while (!lock.compareAndSet(false, true)) {
-            Thread.yield();
-        }
         try {
+            lock.lock();
             if (!halfClosed.get()) {
                 action.run();
             }
         } finally {
-            lock.set(false);
+            lock.unlock();
         }
     }
 }