Merge pull request #15219 from maenolis/BAEL-7014

BAEL 7014

core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java

@@ -0,0 +1,16 @@
+package com.baeldung.lazylambda;
+
+import java.util.function.Supplier;
+
+public class LambdaSupplier<T> {
+
+    protected final Supplier<T> expensiveData;
+
+    public LambdaSupplier(Supplier<T> expensiveData) {
+        this.expensiveData = expensiveData;
+    }
+
+    public T getData() {
+        return expensiveData.get();
+    }
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java

@@ -0,0 +1,21 @@
+package com.baeldung.lazylambda;
+
+import java.util.function.Supplier;
+
+public class LazyLambdaSupplier<T> extends LambdaSupplier<T> {
+
+    private T data;
+
+    public LazyLambdaSupplier(Supplier<T> expensiveData) {
+        super(expensiveData);
+    }
+
+    @Override
+    public T getData() {
+        if (data != null) {
+            return data;
+        }
+        return data = expensiveData.get();
+    }
+
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java

@@ -0,0 +1,26 @@
+package com.baeldung.lazylambda;
+
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
+
+public class LazyLambdaThreadSafeSupplier<T> extends LambdaSupplier<T> {
+
+    private final AtomicReference<T> data;
+
+    public LazyLambdaThreadSafeSupplier(Supplier<T> expensiveData) {
+        super(expensiveData);
+        data = new AtomicReference<>();
+    }
+
+    public T getData() {
+        if (data.get() == null) {
+            synchronized (data) {
+                if (data.get() == null) {
+                    data.set(expensiveData.get());
+                }
+            }
+        }
+        return data.get();
+    }
+
+}

core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.lazylambda;
+
+import java.util.function.Supplier;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+public class LambdaSupplierUnitTest {
+
+    @Test
+    public void whenCalledMultipleTimes_thenShouldBeCalledMultipleTimes() {
+        @SuppressWarnings("unchecked") Supplier<String> mockedExpensiveFunction = Mockito.mock(Supplier.class);
+        Mockito.when(mockedExpensiveFunction.get())
+            .thenReturn("expensive call");
+        LambdaSupplier<String> testee = new LambdaSupplier<>(mockedExpensiveFunction);
+        Mockito.verify(mockedExpensiveFunction, Mockito.never())
+            .get();
+        testee.getData();
+        testee.getData();
+        Mockito.verify(mockedExpensiveFunction, Mockito.times(2))
+            .get();
+    }
+
+}

core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.lazylambda;
+
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.stubbing.Answer;
+
+public class LazyLambdaSupplierUnitTest {
+
+    @Test
+    public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() {
+        @SuppressWarnings("unchecked") Supplier<String> mockedExpensiveFunction = Mockito.mock(Supplier.class);
+        Mockito.when(mockedExpensiveFunction.get())
+            .thenReturn("expensive call");
+        LazyLambdaSupplier<String> testee = new LazyLambdaSupplier<>(mockedExpensiveFunction);
+        Mockito.verify(mockedExpensiveFunction, Mockito.never())
+            .get();
+        testee.getData();
+        testee.getData();
+        Mockito.verify(mockedExpensiveFunction, Mockito.times(1))
+            .get();
+    }
+
+    @Test
+    public void whenCalledMultipleTimesConcurrently_thenShouldBeCalledMultipleTimes() throws InterruptedException {
+        @SuppressWarnings("unchecked") Supplier<String> mockedExpensiveFunction = Mockito.mock(Supplier.class);
+        Mockito.when(mockedExpensiveFunction.get())
+            .thenAnswer((Answer<String>) invocation -> {
+                Thread.sleep(1000L);
+                return "Late response!";
+            });
+        LazyLambdaSupplier<String> testee = new LazyLambdaSupplier<>(mockedExpensiveFunction);
+        Mockito.verify(mockedExpensiveFunction, Mockito.never())
+            .get();
+
+        ExecutorService executorService = Executors.newFixedThreadPool(4);
+        executorService.invokeAll(List.of(testee::getData, testee::getData));
+        executorService.shutdown();
+        if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
+            executorService.shutdownNow();
+        }
+
+        Mockito.verify(mockedExpensiveFunction, Mockito.times(2))
+            .get();
+    }
+}

core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.lazylambda;
+
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.stubbing.Answer;
+
+public class LazyLambdaThreadSafeSupplierUnitTest {
+
+    @Test
+    public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() {
+        @SuppressWarnings("unchecked") Supplier<String> mockedExpensiveFunction = Mockito.mock(Supplier.class);
+        Mockito.when(mockedExpensiveFunction.get())
+            .thenReturn("expensive call");
+        LazyLambdaThreadSafeSupplier<String> testee = new LazyLambdaThreadSafeSupplier<>(mockedExpensiveFunction);
+        Mockito.verify(mockedExpensiveFunction, Mockito.never())
+            .get();
+        testee.getData();
+        testee.getData();
+        Mockito.verify(mockedExpensiveFunction, Mockito.times(1))
+            .get();
+    }
+
+    @Test
+    public void whenCalledMultipleTimesConcurrently_thenShouldBeCalledOnlyOnce() throws InterruptedException {
+        @SuppressWarnings("unchecked") Supplier<String> mockedExpensiveFunction = Mockito.mock(Supplier.class);
+        Mockito.when(mockedExpensiveFunction.get())
+            .thenAnswer((Answer<String>) invocation -> {
+                Thread.sleep(1000L);
+                return "Late response!";
+            });
+        LazyLambdaThreadSafeSupplier<String> testee = new LazyLambdaThreadSafeSupplier<>(mockedExpensiveFunction);
+        Mockito.verify(mockedExpensiveFunction, Mockito.never())
+            .get();
+
+        ExecutorService executorService = Executors.newFixedThreadPool(4);
+        executorService.invokeAll(List.of(testee::getData, testee::getData));
+        executorService.shutdown();
+        if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
+            executorService.shutdownNow();
+        }
+
+        Mockito.verify(mockedExpensiveFunction, Mockito.times(1))
+            .get();
+    }
+
+}