Java02. ДЗ 01, Васильев Роман

build.gradle

@@ -0,0 +1,14 @@
+group 'com.github.nizshee'
+version '1.0-SNAPSHOT'
+
+apply plugin: 'java'
+
+sourceCompatibility = 1.8
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile group: 'junit', name: 'junit', version: '4.11'
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Sat Sep 10 19:34:51 MSK 2016
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.13-bin.zip

settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'lazy-factory'
+

src/main/java/com/github/nizshee/Lazy.java

@@ -0,0 +1,6 @@
+package com.github.nizshee;
+
+@SuppressWarnings("all")
+public interface Lazy<T> {
+    T get();
+}

src/main/java/com/github/nizshee/LazyFactory.java

@@ -0,0 +1,60 @@
+package com.github.nizshee;
+
+
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Supplier;
+
+@SuppressWarnings("all")
+public class LazyFactory {
+
+    public static <T> Lazy<T> createLazySimple(Supplier<T> supplier) {
+        return new Lazy<T>() {
+            private Optional<T> optional = Optional.empty();
+
+            @Override
+            public T get() {
+                if (!optional.isPresent()) {
+                    optional = Optional.of(supplier.get());
+                }
+                return optional.get();
+            }
+        };
+    }
+
+    public static <T> Lazy<T> createLazyConcurent(Supplier<T> supplier) {
+        return new Lazy<T>() {
+            private final Object monitor = new Object();
+            private Optional<T> optional = Optional.empty();
+
+            @Override
+            public T get() {
+                if (!optional.isPresent()) {
+                    synchronized (monitor) {
+                        if (!optional.isPresent()) {
+                            optional = Optional.of(supplier.get());
+                        }
+                    }
+                }
+                return optional.get();
+            }
+        };
+    }
+
+    public static <T> Lazy<T> createLazyLockFree(Supplier<T> supplier) {
+        return new Lazy<T>() {
+            final private AtomicReference<Optional<T>> optionalReference = new AtomicReference<>(Optional.empty());
+
+            @Override
+            public T get() {
+                if (!optionalReference.get().isPresent()) {
+                    Optional<T> newOptional = Optional.of(supplier.get());
+                    optionalReference.compareAndSet(Optional.empty(), newOptional);
+                }
+                return optionalReference.get().get();
+            }
+        };
+    }
+
+
+}