gaspersic/java-design-patterns
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
Refactor singleton according to checkstyle rules
This commit is contained in:
Ilkka Seppälä 2015-09-24 22:32:11 +03:00
commit c1fda3ad6c
6 changed files with 142 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
singleton/src/main/java/com/iluwatar/singleton/App.java
View File

@ -1,55 +1,63 @@
/**
* Singleton pattern.
*/
package com.iluwatar.singleton; package com.iluwatar.singleton;
/** /**
*
* Singleton pattern ensures that the class ({@link IvoryTower}) can have only one * Singleton pattern ensures that the class ({@link IvoryTower}) can have only one
* existing instance per Java classloader instance and provides global access to it. * 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 * 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 * http://stackoverflow.com/questions/17721263/singleton-across-jvm-or-application-instance-or-tomcat-instance
*/ */
public class App { public class App {
/** /**
* Program entry point * Program entry point.
* @param args command line args *
*/ * @param args command line args
public static void main(String[] args) { */
public static void main(String[] args) {
// eagerly initialized singleton // eagerly initialized singleton
IvoryTower ivoryTower1 = IvoryTower.getInstance(); IvoryTower ivoryTower1 = IvoryTower.getInstance();
IvoryTower ivoryTower2 = IvoryTower.getInstance(); IvoryTower ivoryTower2 = IvoryTower.getInstance();
System.out.println("ivoryTower1=" + ivoryTower1); System.out.println("ivoryTower1=" + ivoryTower1);
System.out.println("ivoryTower2=" + ivoryTower2); System.out.println("ivoryTower2=" + ivoryTower2);
// lazily initialized singleton // lazily initialized singleton
ThreadSafeLazyLoadedIvoryTower threadSafeIvoryTower1 = ThreadSafeLazyLoadedIvoryTower ThreadSafeLazyLoadedIvoryTower threadSafeIvoryTower1 = ThreadSafeLazyLoadedIvoryTower
.getInstance(); .getInstance();
ThreadSafeLazyLoadedIvoryTower threadSafeIvoryTower2 = ThreadSafeLazyLoadedIvoryTower ThreadSafeLazyLoadedIvoryTower threadSafeIvoryTower2 = ThreadSafeLazyLoadedIvoryTower
.getInstance(); .getInstance();
System.out.println("threadSafeIvoryTower1=" + threadSafeIvoryTower1); System.out.println("threadSafeIvoryTower1=" + threadSafeIvoryTower1);
System.out.println("threadSafeIvoryTower2=" + threadSafeIvoryTower2); System.out.println("threadSafeIvoryTower2=" + threadSafeIvoryTower2);
// enum singleton // enum singleton
EnumIvoryTower enumIvoryTower1 = EnumIvoryTower.INSTANCE; EnumIvoryTower enumIvoryTower1 = EnumIvoryTower.INSTANCE;
EnumIvoryTower enumIvoryTower2 = EnumIvoryTower.INSTANCE; EnumIvoryTower enumIvoryTower2 = EnumIvoryTower.INSTANCE;
System.out.println("enumIvoryTower1=" + enumIvoryTower1); System.out.println("enumIvoryTower1=" + enumIvoryTower1);
System.out.println("enumIvoryTower2=" + enumIvoryTower2); System.out.println("enumIvoryTower2=" + enumIvoryTower2);
InitializingOnDemandHolderIdiom demandHolderIdiom = InitializingOnDemandHolderIdiom.getInstance(); InitializingOnDemandHolderIdiom demandHolderIdiom =
System.out.println(demandHolderIdiom); InitializingOnDemandHolderIdiom.getInstance();
InitializingOnDemandHolderIdiom demandHolderIdiom2 = InitializingOnDemandHolderIdiom.getInstance(); System.out.println(demandHolderIdiom);
System.out.println(demandHolderIdiom2); InitializingOnDemandHolderIdiom demandHolderIdiom2 =
InitializingOnDemandHolderIdiom.getInstance();
ThreadSafeDoubleCheckLocking dcl1 = ThreadSafeDoubleCheckLocking.getInstance(); System.out.println(demandHolderIdiom2);
System.out.println(dcl1);
ThreadSafeDoubleCheckLocking dcl2 = ThreadSafeDoubleCheckLocking.getInstance(); ThreadSafeDoubleCheckLocking dcl1 = ThreadSafeDoubleCheckLocking.getInstance();
System.out.println(dcl2); System.out.println(dcl1);
} ThreadSafeDoubleCheckLocking dcl2 = ThreadSafeDoubleCheckLocking.getInstance();
System.out.println(dcl2);
}
} }

16
singleton/src/main/java/com/iluwatar/singleton/EnumIvoryTower.java
View File

@ -1,17 +1,15 @@
package com.iluwatar.singleton; package com.iluwatar.singleton;
/** /**
* * Enum based singleton implementation.
* Enum Singleton class.
* Effective Java 2nd Edition (Joshua Bloch) p. 18 * Effective Java 2nd Edition (Joshua Bloch) p. 18
*
*/ */
public enum EnumIvoryTower { public enum EnumIvoryTower {
INSTANCE;
@Override INSTANCE;
public String toString() {
return getDeclaringClass().getCanonicalName() + "@" + hashCode(); @Override
} public String toString() {
return getDeclaringClass().getCanonicalName() + "@" + hashCode();
}
} }

34
singleton/src/main/java/com/iluwatar/singleton/InitializingOnDemandHolderIdiom.java
View File

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

28
singleton/src/main/java/com/iluwatar/singleton/IvoryTower.java
View File

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

64
singleton/src/main/java/com/iluwatar/singleton/ThreadSafeDoubleCheckLocking.java
View File

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

31
singleton/src/main/java/com/iluwatar/singleton/ThreadSafeLazyLoadedIvoryTower.java
View File

@ -1,28 +1,27 @@
package com.iluwatar.singleton; package com.iluwatar.singleton;
/** /**
*
* Thread-safe Singleton class. * Thread-safe Singleton class.
* The instance is lazily initialized and thus needs synchronization * The instance is lazily initialized and thus needs synchronization
* mechanism. * mechanism.
*
*/ */
public class ThreadSafeLazyLoadedIvoryTower { public class ThreadSafeLazyLoadedIvoryTower {
private static ThreadSafeLazyLoadedIvoryTower instance = null; private static ThreadSafeLazyLoadedIvoryTower instance = null;
private ThreadSafeLazyLoadedIvoryTower() {
}
public synchronized static ThreadSafeLazyLoadedIvoryTower getInstance() { private ThreadSafeLazyLoadedIvoryTower() {
/* }
* The instance gets created only when it is called for first time.
* Lazy-loading
*/
if (instance == null) {
instance = new ThreadSafeLazyLoadedIvoryTower();
}
return instance; /**
} * 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();
}
return instance;
}
} }