working on updating concurrent array api

Author: JavaSaBr

rlib-common/src/main/java/com/ss/rlib/common/concurrent/deadlock/DeadLockDetector.java

@@ -6,6 +6,7 @@
 import com.ss.rlib.common.util.array.Array;
 import com.ss.rlib.common.util.array.ArrayFactory;
 import com.ss.rlib.common.util.array.ConcurrentArray;
+import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -29,38 +30,29 @@ public class DeadLockDetector implements Runnable {
     /**
      * The list of listeners.
      */
-    @NotNull
-    private final ConcurrentArray<DeadLockListener> listeners;
+    private final @Getter @NotNull ConcurrentArray<DeadLockListener> listeners;
 
     /**
      * The bean with information about threads.
      */
-    @NotNull
-    private final ThreadMXBean mxThread;
+    private final @NotNull ThreadMXBean mxThread;
 
     /**
      * The scheduler.
      */
-    @NotNull
-    private final ScheduledExecutorService executorService;
+    private final @NotNull ScheduledExecutorService executorService;
 
     /**
      * The reference to a task.
      */
-    @Nullable
-    private volatile ScheduledFuture<?> schedule;
+    private volatile @Getter @Nullable ScheduledFuture<?> schedule;
 
     /**
      * The checking interval.
      */
     private final int interval;
 
-    /**
-     * Instantiates a new Dead lock detector.
-     *
-     * @param interval the checking interval.
-     */
-    public DeadLockDetector(final int interval) {
+    public DeadLockDetector(int interval) {
 
         if (interval < 1) {
             throw new IllegalArgumentException("negative interval.");
@@ -77,54 +69,44 @@ public DeadLockDetector(final int interval) {
      *
      * @param listener the new listener.
      */
-    public void addListener(@NotNull final DeadLockListener listener) {
-        ArrayUtils.runInWriteLock(listeners, listener, Array::add);
-    }
-
-    /**
-     * Gets listeners.
-     *
-     * @return the list of listeners.
-     */
-    @NotNull
-    public ConcurrentArray<DeadLockListener> getListeners() {
-        return listeners;
+    public void addListener(@NotNull DeadLockListener listener) {
+        listeners.runInWriteLock(listener, Array::add);
     }
 
     @Override
     public void run() {
 
-        final long[] threadIds = mxThread.findDeadlockedThreads();
-        if (threadIds.length < 1) return;
+        var threadIds = mxThread.findDeadlockedThreads();
+
+        if (threadIds.length < 1) {
+            return;
+        }
+
+        var listeners = getListeners();
 
-        final ConcurrentArray<DeadLockListener> listeners = getListeners();
+        for (var id : threadIds) {
 
-        for (final long id : threadIds) {
+            var info = mxThread.getThreadInfo(id);
 
-            final ThreadInfo info = mxThread.getThreadInfo(id);
-            if (listeners.isEmpty()) continue;
+            if (listeners.isEmpty()) {
+                continue;
+            }
 
-            ArrayUtils.runInReadLock(listeners, info,
-                    (deadLockListeners, threadInfo) ->
-                            deadLockListeners.forEach(threadInfo, DeadLockListener::onDetected));
+            listeners.runInReadLock(info, (list, inf) -> list.forEach(inf, DeadLockListener::onDetected));
 
             LOGGER.warning("DeadLock detected! : " + info);
         }
     }
 
-    /**
-     * @return the reference to a task.
-     */
-    @Nullable
-    private ScheduledFuture<?> getSchedule() {
-        return schedule;
-    }
-
     /**
      * Start.
      */
     public synchronized void start() {
-        if (schedule != null) return;
+
+        if (schedule != null) {
+            return;
+        }
+
         schedule = executorService.scheduleAtFixedRate(this, interval, interval, TimeUnit.MILLISECONDS);
     }
 
@@ -133,8 +115,12 @@ public synchronized void start() {
      */
     public synchronized void stop() {
 
-        final ScheduledFuture<?> schedule = getSchedule();
-        if (schedule == null) return;
+        var schedule = getSchedule();
+
+        if (schedule == null) {
+            return;
+        }
+
         schedule.cancel(false);
 
         this.schedule = null;

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullBiConsumer.java

@@ -0,0 +1,12 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiConsumer;
+
+@FunctionalInterface
+public interface NotNullBiConsumer<T, U> extends BiConsumer<T, U> {
+
+    @Override
+    void accept(@NotNull T first, @NotNull U second);
+}

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullBiFunction.java

@@ -0,0 +1,12 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiFunction;
+
+@FunctionalInterface
+public interface NotNullBiFunction<T, U, R> extends BiFunction<T, U, R> {
+
+    @Override
+    @NotNull R apply(@NotNull T first, @NotNull U second);
+}

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullBiPredicate.java

@@ -0,0 +1,12 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.BiPredicate;
+
+@FunctionalInterface
+public interface NotNullBiPredicate<T, U> extends BiPredicate<T, U> {
+
+    @Override
+    boolean test(@NotNull T first, @NotNull U second);
+}

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullConsumer.java

@@ -0,0 +1,12 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Consumer;
+
+@FunctionalInterface
+public interface NotNullConsumer<T> extends Consumer<T> {
+
+    @Override
+    void accept(@NotNull T object);
+}

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullFunction.java

@@ -0,0 +1,12 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Function;
+
+@FunctionalInterface
+public interface NotNullFunction<T, R> extends Function<T, R> {
+
+    @Override
+    @NotNull R apply(@NotNull T object);
+}

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullNullableBiFunction.java

@@ -0,0 +1,13 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiFunction;
+
+@FunctionalInterface
+public interface NotNullNullableBiFunction<T, U, R> extends BiFunction<T, U, R> {
+
+    @Override
+    @Nullable R apply(@NotNull T first, @NotNull U second);
+}

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullNullableFunction.java

@@ -0,0 +1,13 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Function;
+
+@FunctionalInterface
+public interface NotNullNullableFunction<T, R> extends Function<T, R> {
+
+    @Override
+    @Nullable R apply(@NotNull T object);
+}

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullObjectIntPredicate.java

@@ -0,0 +1,13 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author JavaSaBr
+ */
+@FunctionalInterface
+public interface NotNullObjectIntPredicate<T> extends ObjectIntPredicate<T> {
+
+    @Override
+    boolean test(@NotNull T first, int second);
+}

rlib-common/src/main/java/com/ss/rlib/common/function/NotNullPredicate.java

@@ -0,0 +1,12 @@
+package com.ss.rlib.common.function;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Predicate;
+
+@FunctionalInterface
+public interface NotNullPredicate<T> extends Predicate<T> {
+
+    @Override
+    boolean test(@NotNull T object);
+}