yegor256#551 CR

src/main/java/org/cactoos/func/SyncFunc.java

@@ -25,6 +25,7 @@
 
 import java.util.concurrent.Callable;
 import org.cactoos.Func;
+import org.cactoos.Proc;
 
 /**
  * Func that is thread-safe.
@@ -49,6 +50,16 @@ public final class SyncFunc<X, Y> implements Func<X, Y> {
      */
     private final Object lock;
 
+    /**
+     * Ctor.
+     * @param runnable Func original
+     * @param result Result to return
+     * @since 0.32
+     */
+    public SyncFunc(final Runnable runnable, final Y result) {
+        this(new FuncOf<>(runnable, result));
+    }
+
     /**
      * Ctor.
      * @param callable Func original
@@ -58,6 +69,16 @@ public SyncFunc(final Callable<Y> callable) {
         this(new FuncOf<>(callable));
     }
 
+    /**
+     * Ctor.
+     * @param proc Func original
+     * @param result Result to return
+     * @since 0.32
+     */
+    public SyncFunc(final Proc<X> proc, final Y result) {
+        this(new FuncOf<>(proc, result));
+    }
+
     /**
      * Ctor.
      * @param fnc Func original

src/test/java/org/cactoos/func/SyncFuncTest.java

@@ -59,6 +59,26 @@ public void funcWorksInThreads() {
         MatcherAssert.assertThat(list.size(), Matchers.equalTo(threads));
     }
 
+    @Test
+    public void procWorksInThreads() {
+        final int threads = 100;
+        final int[] counter = new int[]{0};
+        MatcherAssert.assertThat(
+            "Sync func with proc can't work well in multiple threads",
+            func -> func.apply(1),
+            new RunsInThreads<>(
+                new SyncFunc<Integer, Boolean>(
+                    new ProcOf<>(
+                        input -> counter[0] = counter[0] + input
+                    ),
+                    true
+                ),
+                threads
+            )
+        );
+        MatcherAssert.assertThat(counter[0], Matchers.equalTo(threads));
+    }
+
     @Test
     public void callableWorksInThreads() {
         final int threads = 100;
@@ -78,4 +98,22 @@ public void callableWorksInThreads() {
         );
         MatcherAssert.assertThat(counter[0], Matchers.equalTo(threads));
     }
+
+    @Test
+    public void runnableWorksInThreads() {
+        final int threads = 100;
+        final int[] counter = new int[]{0};
+        MatcherAssert.assertThat(
+            "Sync func with runnable can't work well in multiple threads",
+            func -> func.apply(1),
+            new RunsInThreads<>(
+                new SyncFunc<Integer, Boolean>(
+                    () -> counter[0] = counter[0] + 1,
+                    true
+                ),
+                threads
+            )
+        );
+        MatcherAssert.assertThat(counter[0], Matchers.equalTo(threads));
+    }
 }