Merge pull request #254 from zafarella/refactor-singleton-according-to-checkstyle

Refactor singleton according to checkstyle rules

singleton/src/main/java/com/iluwatar/singleton/App.java

@@ -1,23 +1,29 @@
+/**
+ * Singleton pattern.
+ */
+
 package com.iluwatar.singleton;
 
 /**
- *
  * Singleton pattern ensures that the class ({@link IvoryTower}) can have only one
  * existing instance per Java classloader instance and provides global access to it.
- * <p>
+ * <p/>
  * http://stackoverflow.com/questions/70689/what-is-an-efficient-way-to-implement-a-singleton-pattern-in-java
- *<p>
+ * <p/>
- * The risk of this pattern is that bugs resulting from setting a singleton up in a distributed environment can 
+ * The risk of this pattern is that bugs resulting from setting a singleton up in
- * be tricky to debug, since it will work fine if you debug with a single classloader. Additionally, these
+ * a distributed environment can be tricky to debug, since it will work fine if you
- * problems can crop up a while after the implementation of a singleton, since they may start out synchronous and
+ * debug with a single classloader. Additionally, these problems can crop up a while
- * only become async with time, so you it may not be clear why you are seeing certain changes in behaviour.
+ * after the implementation of a singleton, since they may start out synchronous and
- * <p>
+ * only become async with time, so you it may not be clear why you are seeing certain
+ * changes in behaviour.
+ * <p/>
  * http://stackoverflow.com/questions/17721263/singleton-across-jvm-or-application-instance-or-tomcat-instance
  */
 public class App {
 
   /**
-	 * Program entry point
+   * Program entry point.
+   *
    * @param args command line args
    */
   public static void main(String[] args) {
@@ -42,9 +48,11 @@ public class App {
     System.out.println("enumIvoryTower1=" + enumIvoryTower1);
     System.out.println("enumIvoryTower2=" + enumIvoryTower2);
 
-		InitializingOnDemandHolderIdiom demandHolderIdiom = InitializingOnDemandHolderIdiom.getInstance();
+    InitializingOnDemandHolderIdiom demandHolderIdiom =
+            InitializingOnDemandHolderIdiom.getInstance();
     System.out.println(demandHolderIdiom);
-		InitializingOnDemandHolderIdiom demandHolderIdiom2 = InitializingOnDemandHolderIdiom.getInstance();
+    InitializingOnDemandHolderIdiom demandHolderIdiom2 =
+            InitializingOnDemandHolderIdiom.getInstance();
     System.out.println(demandHolderIdiom2);
 
     ThreadSafeDoubleCheckLocking dcl1 = ThreadSafeDoubleCheckLocking.getInstance();

singleton/src/main/java/com/iluwatar/singleton/EnumIvoryTower.java

@@ -1,10 +1,8 @@
 package com.iluwatar.singleton;
 
 /**
- *
+ * Enum based singleton implementation.
- * Enum Singleton class.
  * Effective Java 2nd Edition (Joshua Bloch) p. 18
- *
  */
 public enum EnumIvoryTower {
 

singleton/src/main/java/com/iluwatar/singleton/InitializingOnDemandHolderIdiom.java

@@ -7,30 +7,30 @@ import java.io.Serializable;
  * creating lazy initialized singleton object in Java.
  * refer to "The CERT Oracle Secure Coding Standard for Java"
  * By Dhruv Mohindra, Robert C. Seacord p.378
- * <p>
+ * <p/>
  * Singleton objects usually are heavy to create and sometimes need to serialize them.
  * This class also shows how to preserve singleton in serialized version of singleton.
  *
  * @author mortezaadi@gmail.com
- *
  */
-public class InitializingOnDemandHolderIdiom implements Serializable{
+public class InitializingOnDemandHolderIdiom implements Serializable {
 
   private static final long serialVersionUID = 1L;
 
-	private static class HelperHolder {
+  private InitializingOnDemandHolderIdiom() {
-		public static final InitializingOnDemandHolderIdiom INSTANCE = new InitializingOnDemandHolderIdiom();
   }
 
   public static InitializingOnDemandHolderIdiom getInstance() {
     return HelperHolder.INSTANCE;
   }
 
-	private InitializingOnDemandHolderIdiom() {
-	}
-
   protected Object readResolve() {
     return getInstance();
   }
 
+  private static class HelperHolder {
+    public static final InitializingOnDemandHolderIdiom INSTANCE =
+            new InitializingOnDemandHolderIdiom();
+  }
+
 }

singleton/src/main/java/com/iluwatar/singleton/IvoryTower.java

@@ -1,19 +1,29 @@
 package com.iluwatar.singleton;
 
 /**
- * 
  * Singleton class.
  * Eagerly initialized static instance guarantees thread
  * safety.
- * 
  */
-public class IvoryTower {
+public final class IvoryTower {
 
+  /**
+   * Static to class instance of the class.
+   */
   private static IvoryTower instance = new IvoryTower();
 
+  /**
+   * Private constructor so nobody can instantiate the class.
+   */
   private IvoryTower() {
   }
 
+  /**
+   * To be called by user to
+   * obtain instance of the class.
+   *
+   * @return instance of the singleton.
+   */
   public static IvoryTower getInstance() {
     return instance;
   }

singleton/src/main/java/com/iluwatar/singleton/ThreadSafeDoubleCheckLocking.java

@@ -2,13 +2,12 @@ package com.iluwatar.singleton;
 
 /**
  * Double check locking
- * <p>
+ * <p/>
  * http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
- * <p>
+ * <p/>
  * Broken under Java 1.4.
  *
  * @author mortezaadi@gmail.com
- *
  */
 public class ThreadSafeDoubleCheckLocking {
 
@@ -16,14 +15,19 @@ public class ThreadSafeDoubleCheckLocking {
 
   /**
    * private constructor to prevent client from instantiating.
-	 * 
    */
   private ThreadSafeDoubleCheckLocking() {
     //to prevent instantiating by Reflection call
-		if(INSTANCE != null)
+    if (INSTANCE != null) {
       throw new IllegalStateException("Already initialized.");
     }
+  }
 
+  /**
+   * Public accessor.
+   *
+   * @return an instance of the class.
+   */
   public static ThreadSafeDoubleCheckLocking getInstance() {
     //local variable increases performance by 25 percent
     //Joshua Bloch "Effective Java, Second Edition", p. 283-284

singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java

@@ -1,11 +1,9 @@
 package com.iluwatar.singleton;
 
 /**
- *
  * Thread-safe Singleton class.
  * The instance is lazily initialized and thus needs synchronization
  * mechanism.
- *
  */
 public class ThreadSafeLazyLoadedIvoryTower {
 
@@ -14,11 +12,12 @@ public class ThreadSafeLazyLoadedIvoryTower {
   private ThreadSafeLazyLoadedIvoryTower() {
   }
 
-	public synchronized static ThreadSafeLazyLoadedIvoryTower getInstance() {
+  /**
-		/*
    * The instance gets created only when it is called for first time.
    * Lazy-loading
    */
+  public synchronized static ThreadSafeLazyLoadedIvoryTower getInstance() {
+
     if (instance == null) {
       instance = new ThreadSafeLazyLoadedIvoryTower();
     }