What is an efficient way to implement a singleton pattern in Java

Question

User · Answer

Make sure that you really need it  Do a google search for  quot singleton anti-pattern quot  to see some arguments against it  There s nothing inherently wrong with it I suppose  but it s just a mechanism for exposing some global resource data so make sure that this is the best way  In particular  I ve found dependency injection  DI  more useful particularly if you are also using unit tests  because DI allows you to use mocked resources for testing purposes

User · Answer

Depending on the usage  there are several  quot correct quot  answers  Since Java 5  the best way to do it is to use an enum  public enum Foo      INSTANCE     Pre Java 5  the most simple case is  public final class Foo        private static final Foo INSTANCE   new Foo         private Foo             if  INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return INSTANCE             public Object clone   throws CloneNotSupportedException          throw new CloneNotSupportedException  quot Cannot clone instance of this class quot             Let s go over the code  First  you want the class to be final  In this case  I ve used the final keyword to let the users know it is final  Then you need to make the constructor private to prevent users to create their own Foo  Throwing an exception from the constructor prevents users to use reflection to create a second Foo  Then you create a private static final Foo field to hold the only instance  and a public static Foo getInstance   method to return it  The Java specification makes sure that the constructor is only called when the class is first used  When you have a very large object or heavy construction code and also have other accessible static methods or fields that might be used before an instance is needed  then and only then you need to use lazy initialization  You can use a private static class to load the instance  The code would then look like  public final class Foo        private static class FooLoader           private static final Foo INSTANCE   new Foo               private Foo             if  FooLoader INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return FooLoader INSTANCE           Since the line private static final Foo INSTANCE   new Foo    is only executed when the class FooLoader is actually used  this takes care of the lazy instantiation  and is it guaranteed to be thread safe  When you also want to be able to serialize your object you need to make sure that deserialization won t create a copy  public final class Foo implements Serializable        private static final long serialVersionUID   1L       private static class FooLoader           private static final Foo INSTANCE   new Foo               private Foo             if  FooLoader INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return FooLoader INSTANCE              SuppressWarnings  quot unused quot       private Foo readResolve             return FooLoader INSTANCE           The method readResolve   will make sure the only instance will be returned  even when the object was serialized in a previous run of your program

User · Answer

Another argument often used against singletons is their testability problems  Singletons are not easily mockable for testing purposes  If this turns out to be a problem  I like to make the following slight modification  public class SingletonImpl        private static SingletonImpl instance       public static SingletonImpl getInstance             if  instance    null                instance   new SingletonImpl                      return instance             public static void setInstance SingletonImpl impl            instance   impl             public void a             System out println  quot Default Method quot             The added setInstance method allows setting a mockup implementation of the singleton class during testing  public class SingletonMock extends SingletonImpl         Override     public void a             System out println  quot Mock Method quot              This also works with early initialization approaches  public class SingletonImpl        private static final SingletonImpl instance   new SingletonImpl         private static SingletonImpl alt       public static void setInstance SingletonImpl inst            alt   inst             public static SingletonImpl getInstance             if  alt    null                return alt                    return instance             public void a             System out println  quot Default Method quot             public class SingletonMock extends SingletonImpl         Override     public void a             System out println  quot Mock Method quot              This has the drawback of exposing this functionality to the normal application too  Other developers working on that code could be tempted to use the   setInstance   method to alter a specific function and thus changing the whole application behaviour  and therefore this method should contain at least a good warning in its javadoc  Still  for the possibility of mockup-testing  when needed   this code exposure may be an acceptable price to pay

User · Answer

Forget lazy initialization  it s too problematic  This is the simplest solution  public class A            private static final A INSTANCE   new A         private A           public static A getInstance             return INSTANCE

User · Answer

For JSE 5 0 and above  take the Enum approach  Otherwise  use the static singleton holder approach   a lazy loading approach described by Bill Pugh   The latter solution is also thread-safe without requiring special language constructs  i e   volatile or synchronized

User · Answer

Have a look at this post  Examples of GoF Design Patterns in Java  39 s core libraries From the best answer s  quot Singleton quot  section   Singleton  recognizeable by creational methods returning the same instance  usually of itself  everytime   java lang Runtime getRuntime   java awt Desktop getDesktop   java lang System getSecurityManager     You can also learn the example of Singleton from Java native classes themselves

User · Answer

Version 1   public class MySingleton       private static MySingleton instance   null      private MySingleton          public static synchronized MySingleton getInstance             if instance    null                instance   new MySingleton                      return instance            Lazy loading  thread safe with blocking  low performance because of synchronized   Version 2   public class MySingleton       private MySingleton          private static class MySingletonHolder           public final static MySingleton instance   new MySingleton              public static MySingleton getInstance             return MySingletonHolder instance            Lazy loading  thread safe with non-blocking  high performance

User · Answer

If you do not need lazy loading then simply try  public class Singleton       private final static Singleton INSTANCE   new Singleton         private Singleton           public static Singleton getInstance     return Singleton INSTANCE         protected Object clone             throw new CloneNotSupportedException             If you want lazy loading and you want your singleton to be thread-safe  try the double-checking pattern  public class Singleton       private static Singleton instance   null       private Singleton           public static Singleton getInstance             if null    instance                synchronized Singleton class                    if null    instance                        instance   new Singleton                                                      return instance             protected Object clone             throw new CloneNotSupportedException             As the double checking pattern is not guaranteed to work  due to some issue with compilers  I don t know anything more about that   you could also try to synchronize the whole getInstance-method or create a registry for all your singletons

User · Answer

There is a lot of nuance around implementing a singleton  The holder pattern can not be used in many situations  And IMO when using a volatile - you should also use a local variable  Let s start at the beginning and iterate on the problem  You ll see what I mean   The first attempt might look something like this  public class MySingleton         private static MySingleton INSTANCE        public static MySingleton getInstance             if  INSTANCE    null                INSTANCE   new MySingleton                      return INSTANCE                   Here we have the MySingleton class which has a private static member called INSTANCE  and a public static method called getInstance    The first time getInstance   is called  the INSTANCE member is null  The flow will then fall into the creation condition and create a new instance of the MySingleton class  Subsequent calls to getInstance   will find that the INSTANCE variable is already set  and therefore not create another MySingleton instance  This ensures there is only one instance of MySingleton which is shared among all callers of getInstance    But this implementation has a problem  Multi-threaded applications will have a race condition on the creation of the single instance  If multiple threads of execution hit the getInstance   method at  or around  the same time  they will each see the INSTANCE member as null  This will result in each thread creating a new MySingleton instance and subsequently setting the INSTANCE member   private static MySingleton INSTANCE   public static synchronized MySingleton getInstance         if  INSTANCE    null            INSTANCE   new MySingleton              return INSTANCE     Here we   ve used the synchronized keyword in the method signature to synchronize the getInstance   method  This will certainly fix our race condition  Threads will now block and enter the method one at a time  But it also creates a performance problem  Not only does this implementation synchronize the creation of the single instance  it synchronizes all calls to getInstance    including reads  Reads do not need to be synchronized as they simply return the value of INSTANCE  Since reads will make up the bulk of our calls  remember  instantiation only happens on the first call   we will incur an unnecessary performance hit by synchronizing the entire method   private static MySingleton INSTANCE   public static MySingleton getInstance         if  INSTANCE    null            synchronize MySingleton class                INSTANCE   new MySingleton                        return INSTANCE     Here we   ve moved synchronization from the method signature  to a synchronized block that wraps the creation of the MySingleton instance  But does this solve our problem  Well  we are no longer blocking on reads  but we   ve also taken a step backward  Multiple threads will hit the getInstance   method at or around the same time and they will all see the INSTANCE member as null  They will then hit the synchronized block where one will obtain the lock and create the instance  When that thread exits the block  the other threads will contend for the lock  and one by one each thread will fall through the block and create a new instance of our class  So we are right back where we started   private static MySingleton INSTANCE   public static MySingleton getInstance         if  INSTANCE    null            synchronized MySingleton class                if  INSTANCE    null                    INSTANCE   createInstance                                      return INSTANCE     Here we issue another check from inside the block  If the INSTANCE member has already been set  we   ll skip initialization  This is called double-checked locking  This solves our problem of multiple instantiation  But once again  our solution has presented another challenge  Other threads might not    see    that the INSTANCE member has been updated  This is because of how Java optimizes memory operations  Threads copy the original values of variables from main memory into the CPU   s cache  Changes to values are then written to  and read from  that cache  This is a feature of Java designed to optimize performance  But this creates a problem for our singleton implementation  A second thread     being processed by a different CPU or core  using a different cache     will not see the changes made by the first  This will cause the second thread to see the INSTANCE member as null forcing a new instance of our singleton to be created   private static volatile MySingleton INSTANCE   public static MySingleton getInstance         if  INSTANCE    null            synchronized MySingleton class                if  INSTANCE    null                    INSTANCE   createInstance                                      return INSTANCE     We solve this by using the volatile keyword on the declaration of the INSTANCE member  This will tell the compiler to always read from  and write to  main memory  and not the CPU cache  But this simple change comes at a cost  Because we are bypassing the CPU cache  we will take a performance hit each time we operate on the volatile INSTANCE member     which we do four times  We double-check existence  1 and 2   set the value  3   and then return the value  4   One could argue that this path is the fringe case as we only create the instance during the first call of the method  Perhaps a performance hit on creation is tolerable  But even our main use-case  reads  will operate on the volatile member twice  Once to check existence  and again to return its value   private static volatile MySingleton INSTANCE   public static MySingleton getInstance         MySingleton result   INSTANCE      if  result    null            synchronized MySingleton class                result   INSTANCE              if  result    null                    INSTANCE   result   createInstance                                      return result     Since the performance hit is due to operating directly on the volatile member  let   s set a local variable to the value of the volatile and operate on the local variable instead  This will decrease the number of times we operate on the volatile  thereby reclaiming some of our lost performance  Note that we have to set our local variable again when we enter the synchronized block  This ensures it is up to date with any changes that occurred while we were waiting for the lock  I wrote an article about this recently  Deconstructing The Singleton  You can find more information on these examples and an example of the  quot holder quot  pattern there  There is also a real-world example showcasing the double-checked volatile approach

User · Answer

public class Singleton        private static final Singleton INSTANCE   new Singleton         private Singleton             if  INSTANCE    null              throw new IllegalStateException    Already instantiated                         public synchronized static Singleton getInstance             return INSTANCE            As we have added the Synchronized keyword before getInstance  we have avoided the race condition in the case when two threads call the getInstance at the same time

User · Answer

This is how to implement a simple singleton  public class Singleton          It must be static and final to prevent later modification     private static final Singleton INSTANCE   new Singleton            The constructor must be private to prevent external instantiation        private Singleton             The public static method allowing to get the instance        public static Singleton getInstance             return INSTANCE           This is how to properly lazy create your singleton  public class Singleton          The constructor must be private to prevent external instantiation     private Singleton             The public static method allowing to get the instance        public static Singleton getInstance             return SingletonHolder INSTANCE                       The static inner class responsible for creating your instance only on demand         because the static fields of a class are only initialized when the class        is explicitly called and a class initialization is synchronized such that only        one thread can perform it  this rule is also applicable to inner static class        So here INSTANCE will be created only when SingletonHolder INSTANCE        will be called             private static class SingletonHolder           private static final Singleton INSTANCE   new Singleton

User · Answer

If you do not need lazy loading then simply try  public class Singleton       private final static Singleton INSTANCE   new Singleton         private Singleton           public static Singleton getInstance     return Singleton INSTANCE         protected Object clone             throw new CloneNotSupportedException             If you want lazy loading and you want your singleton to be thread-safe  try the double-checking pattern  public class Singleton       private static Singleton instance   null       private Singleton           public static Singleton getInstance             if null    instance                synchronized Singleton class                    if null    instance                        instance   new Singleton                                                      return instance             protected Object clone             throw new CloneNotSupportedException             As the double checking pattern is not guaranteed to work  due to some issue with compilers  I don t know anything more about that   you could also try to synchronize the whole getInstance-method or create a registry for all your singletons

User · Answer

If you do not need lazy loading then simply try  public class Singleton       private final static Singleton INSTANCE   new Singleton         private Singleton           public static Singleton getInstance     return Singleton INSTANCE         protected Object clone             throw new CloneNotSupportedException             If you want lazy loading and you want your singleton to be thread-safe  try the double-checking pattern  public class Singleton       private static Singleton instance   null       private Singleton           public static Singleton getInstance             if null    instance                synchronized Singleton class                    if null    instance                        instance   new Singleton                                                      return instance             protected Object clone             throw new CloneNotSupportedException             As the double checking pattern is not guaranteed to work  due to some issue with compilers  I don t know anything more about that   you could also try to synchronize the whole getInstance-method or create a registry for all your singletons

User · Answer

I still think after Java 1 5  enum is the best available singleton implementation available as it also ensures that  even in the multi threaded environments  only one instance is created  public enum Singleton       INSTANCE     And you are done

User · Answer

There are four ways to create a singleton in Java   Eager initialization singleton  public class Test        private static final Test test   new Test          private Test                  public static Test getTest              return test              Lazy initialization singleton  thread safe   public class Test         private static volatile Test test         private Test                    public static Test getTest              if test    null                 synchronized Test class                     if test    null                         test   new Test                                                          return test              Bill Pugh singleton with holder pattern  preferably the best one   public class Test         private Test                  private static class TestHolder            private static final Test test   new Test                 public static Test getInstance              return TestHolder test              Enum singleton  public enum MySingleton        INSTANCE        private MySingleton              System out println  quot Here quot

User · Answer

Really consider why you need a singleton before writing it  There is a quasi-religious debate about using them which you can quite easily stumble over if you google singletons in Java  Personally  I try to avoid singletons as often as possible for many reasons  again most of which can be found by googling singletons  I feel that quite often singletons are abused because they re easy to understand by everybody  They re used as a mechanism for getting  quot global quot  data into an OO design and they are used because it is easy to circumvent object lifecycle management  or really thinking about how you can do A from inside B   Look at things like inversion of control  IoC  or dependency injection  DI  for a nice middle ground  If you really need one then Wikipedia has a good example of a proper implementation of a singleton

User · Answer

Enum singleton The simplest way to implement a singleton that is thread-safe is using an Enum  public enum SingletonEnum     INSTANCE    public void doSomething        System out println  quot This is a singleton quot           This code works since the introduction of Enum in Java 1 5 Double checked locking If you want to code a    classic    singleton that works in a multithreaded environment  starting from Java 1 5  you should use this one  public class Singleton      private static volatile Singleton instance   null     private Singleton            public static Singleton getInstance         if  instance    null          synchronized  Singleton class           if  instance    null              instance   new Singleton                                return instance         This is not thread-safe before 1 5 because the implementation of the volatile keyword was different  Early loading singleton  works even before Java 1 5  This implementation instantiates the singleton when the class is loaded and provides thread safety  public class Singleton      private static final Singleton instance   new Singleton       private Singleton            public static Singleton getInstance         return instance         public void doSomething        System out println  quot This is a singleton quot

User · Answer

The best singleton pattern I ve ever seen uses the Supplier interface    It s generic and reusable It supports lazy initialization It s only synchronized until it has been initialized  then the blocking supplier is replaced with a non-blocking supplier    See below   public class Singleton lt T gt  implements Supplier lt T gt         private boolean initialized      private Supplier lt T gt  singletonSupplier       public Singleton T singletonValue            this singletonSupplier      - gt  singletonValue             public Singleton Supplier lt T gt  supplier            this singletonSupplier      - gt                   The initial supplier is temporary  it will be replaced after initialization             synchronized  supplier                    if   initialized                        T singletonValue   supplier get                           Now that the singleton value has been initialized                         replace the blocking supplier with a non-blocking supplier                     singletonSupplier      - gt  singletonValue                      initialized   true                                    return singletonSupplier get                                         Override     public T get             return singletonSupplier get

User · Answer

Thread safe in Java 5   class Foo       private static volatile Bar bar   null      public static Bar getBar             if  bar    null                synchronized Foo class                    if  bar    null                      bar   new Bar                                    return bar            Pay attention to the volatile modifier here     It is important because without it  other threads are not guaranteed by the JMM  Java Memory Model  to see changes to its value   The synchronization does not take care of that--it only serializes access to that block of code   Bno s answer details the approach recommended by Bill Pugh  FindBugs  and is arguable better   Go read and vote up his answer too

User · Answer

I m mystified by some of the answers that suggest dependency injection  DI  as an alternative to using singletons  these are unrelated concepts  You can use DI to inject either singleton or non-singleton  e g   per-thread  instances  At least this is true if you use Spring 2 x  I can t speak for other DI frameworks  So my answer to the OP would be  in all but the most trivial sample code  to   Use a DI framework like Spring Framework  then Make it part of your DI configuration whether your dependencies are singletons  request scoped  session scoped  or whatever   This approach gives you a nice decoupled  and therefore flexible and testable  architecture where whether to use a singleton is an easily reversible implementation detail  provided any singletons you use are threadsafe  of course

User · Answer

Really consider why you need a singleton before writing it  There is a quasi-religious debate about using them which you can quite easily stumble over if you google singletons in Java  Personally  I try to avoid singletons as often as possible for many reasons  again most of which can be found by googling singletons  I feel that quite often singletons are abused because they re easy to understand by everybody  They re used as a mechanism for getting  quot global quot  data into an OO design and they are used because it is easy to circumvent object lifecycle management  or really thinking about how you can do A from inside B   Look at things like inversion of control  IoC  or dependency injection  DI  for a nice middle ground  If you really need one then Wikipedia has a good example of a proper implementation of a singleton

User · Answer

Thread safe in Java 5   class Foo       private static volatile Bar bar   null      public static Bar getBar             if  bar    null                synchronized Foo class                    if  bar    null                      bar   new Bar                                    return bar            Pay attention to the volatile modifier here     It is important because without it  other threads are not guaranteed by the JMM  Java Memory Model  to see changes to its value   The synchronization does not take care of that--it only serializes access to that block of code   Bno s answer details the approach recommended by Bill Pugh  FindBugs  and is arguable better   Go read and vote up his answer too

User · Answer

Forget lazy initialization  it s too problematic  This is the simplest solution  public class A            private static final A INSTANCE   new A         private A           public static A getInstance             return INSTANCE

User · Answer

Thread safe in Java 5   class Foo       private static volatile Bar bar   null      public static Bar getBar             if  bar    null                synchronized Foo class                    if  bar    null                      bar   new Bar                                    return bar            Pay attention to the volatile modifier here     It is important because without it  other threads are not guaranteed by the JMM  Java Memory Model  to see changes to its value   The synchronization does not take care of that--it only serializes access to that block of code   Bno s answer details the approach recommended by Bill Pugh  FindBugs  and is arguable better   Go read and vote up his answer too

User · Answer

public class Singleton        private static final Singleton INSTANCE   new Singleton         private Singleton             if  INSTANCE    null              throw new IllegalStateException    Already instantiated                         public synchronized static Singleton getInstance             return INSTANCE            As we have added the Synchronized keyword before getInstance  we have avoided the race condition in the case when two threads call the getInstance at the same time

User · Answer

I still think after Java 1 5  enum is the best available singleton implementation available as it also ensures that  even in the multi threaded environments  only one instance is created  public enum Singleton       INSTANCE     And you are done

User · Answer

Wikipedia has some examples of singletons  also in Java  The Java 5 implementation looks pretty complete  and is thread-safe  double-checked locking applied

User · Answer

Sometimes a simple  static Foo foo   new Foo     is not enough  Just think of some basic data insertion you want to do   On the other hand you would have to synchronize any method that instantiates the singleton variable as such  Synchronisation is not bad as such  but it can lead to performance issues or locking  in very very rare situations using this example  The solution is  public class Singleton        private static Singleton instance   null       static             instance   new Singleton                 do some of your instantiation stuff here            private Singleton               if instance  null                      throw new ErrorYouWant  Singleton double-instantiation  should never happen                            public static getSingleton               return instance             Now what happens  The class is loaded via the class loader  Directly after the class was interpreted from a byte Array  the VM executes the static     - block  that s the whole secret  The static-block is only called once  the time the given class  name  of the given package is loaded by this one class loader

User · Answer

Following are three different approaches  Enum         Singleton pattern example using Java Enum      public enum EasySingleton        INSTANCE       Double checked locking   lazy loading         Singleton pattern example with Double checked Locking      public class DoubleCheckedLockingSingleton         private static volatile DoubleCheckedLockingSingleton INSTANCE         private DoubleCheckedLockingSingleton             public static DoubleCheckedLockingSingleton getInstance               if INSTANCE    null                 synchronized DoubleCheckedLockingSingleton class                        Double checking Singleton instance                  if INSTANCE    null                         INSTANCE   new DoubleCheckedLockingSingleton                                                            return INSTANCE               Static factory method         Singleton pattern example with static factory method       public class Singleton           Initialized during class loading      private static final Singleton INSTANCE   new Singleton             To prevent creating another instance of  Singleton       private Singleton            public static Singleton getSingleton              return INSTANCE

User · Answer

You need the double-checking idiom if you need to load the instance variable of a class lazily  If you need to load a static variable or a singleton lazily  you need the initialization on demand holder idiom  In addition  if the singleton needs to be serializable  all other fields need to be transient and readResolve   method needs to be implemented in order to maintain the singleton object invariant  Otherwise  each time the object is deserialized  a new instance of the object will be created  What readResolve   does is replace the new object read by readObject    which forced that new object to be garbage collected as there is no variable referring to it  public static final INSTANCE         private Object readResolve       return INSTANCE     Original singleton instance

User · Answer

Use an enum   public enum Foo       INSTANCE      Joshua Bloch explained this approach in his Effective Java Reloaded talk at Google I O 2008  link to video  Also see slides 30-32 of his presentation  effective java reloaded pdf       The Right Way to Implement a Serializable Singleton  public enum Elvis       INSTANCE      private final String   favoriteSongs              Hound Dog    Heartbreak Hotel         public void printFavorites             System out println Arrays toString favoriteSongs               Edit  An online portion of  Effective Java  says        This approach is functionally equivalent to the public field approach  except that it is more concise  provides the serialization machinery for free  and provides an ironclad guarantee against multiple instantiation  even in the face of sophisticated serialization or reflection attacks  While this approach has yet to be widely adopted  a single-element enum type is the best way to implement a singleton

User · Answer

Use an enum   public enum Foo       INSTANCE      Joshua Bloch explained this approach in his Effective Java Reloaded talk at Google I O 2008  link to video  Also see slides 30-32 of his presentation  effective java reloaded pdf       The Right Way to Implement a Serializable Singleton  public enum Elvis       INSTANCE      private final String   favoriteSongs              Hound Dog    Heartbreak Hotel         public void printFavorites             System out println Arrays toString favoriteSongs               Edit  An online portion of  Effective Java  says        This approach is functionally equivalent to the public field approach  except that it is more concise  provides the serialization machinery for free  and provides an ironclad guarantee against multiple instantiation  even in the face of sophisticated serialization or reflection attacks  While this approach has yet to be widely adopted  a single-element enum type is the best way to implement a singleton

User · Answer

Make sure that you really need it  Do a google search for  quot singleton anti-pattern quot  to see some arguments against it  There s nothing inherently wrong with it I suppose  but it s just a mechanism for exposing some global resource data so make sure that this is the best way  In particular  I ve found dependency injection  DI  more useful particularly if you are also using unit tests  because DI allows you to use mocked resources for testing purposes

User · Answer

Use an enum   public enum Foo       INSTANCE      Joshua Bloch explained this approach in his Effective Java Reloaded talk at Google I O 2008  link to video  Also see slides 30-32 of his presentation  effective java reloaded pdf       The Right Way to Implement a Serializable Singleton  public enum Elvis       INSTANCE      private final String   favoriteSongs              Hound Dog    Heartbreak Hotel         public void printFavorites             System out println Arrays toString favoriteSongs               Edit  An online portion of  Effective Java  says        This approach is functionally equivalent to the public field approach  except that it is more concise  provides the serialization machinery for free  and provides an ironclad guarantee against multiple instantiation  even in the face of sophisticated serialization or reflection attacks  While this approach has yet to be widely adopted  a single-element enum type is the best way to implement a singleton

User · Answer

Forget lazy initialization  it s too problematic  This is the simplest solution  public class A            private static final A INSTANCE   new A         private A           public static A getInstance             return INSTANCE

User · Answer

Various ways to make a singleton object   As per Joshua Bloch - Enum would be the best   You can use double check locking also   Even an inner static class can be used

User · Answer

Forget lazy initialization  it s too problematic  This is the simplest solution  public class A            private static final A INSTANCE   new A         private A           public static A getInstance             return INSTANCE

User · Answer

There is a lot of nuance around implementing a singleton  The holder pattern can not be used in many situations  And IMO when using a volatile - you should also use a local variable  Let s start at the beginning and iterate on the problem  You ll see what I mean   The first attempt might look something like this  public class MySingleton         private static MySingleton INSTANCE        public static MySingleton getInstance             if  INSTANCE    null                INSTANCE   new MySingleton                      return INSTANCE                   Here we have the MySingleton class which has a private static member called INSTANCE  and a public static method called getInstance    The first time getInstance   is called  the INSTANCE member is null  The flow will then fall into the creation condition and create a new instance of the MySingleton class  Subsequent calls to getInstance   will find that the INSTANCE variable is already set  and therefore not create another MySingleton instance  This ensures there is only one instance of MySingleton which is shared among all callers of getInstance    But this implementation has a problem  Multi-threaded applications will have a race condition on the creation of the single instance  If multiple threads of execution hit the getInstance   method at  or around  the same time  they will each see the INSTANCE member as null  This will result in each thread creating a new MySingleton instance and subsequently setting the INSTANCE member   private static MySingleton INSTANCE   public static synchronized MySingleton getInstance         if  INSTANCE    null            INSTANCE   new MySingleton              return INSTANCE     Here we   ve used the synchronized keyword in the method signature to synchronize the getInstance   method  This will certainly fix our race condition  Threads will now block and enter the method one at a time  But it also creates a performance problem  Not only does this implementation synchronize the creation of the single instance  it synchronizes all calls to getInstance    including reads  Reads do not need to be synchronized as they simply return the value of INSTANCE  Since reads will make up the bulk of our calls  remember  instantiation only happens on the first call   we will incur an unnecessary performance hit by synchronizing the entire method   private static MySingleton INSTANCE   public static MySingleton getInstance         if  INSTANCE    null            synchronize MySingleton class                INSTANCE   new MySingleton                        return INSTANCE     Here we   ve moved synchronization from the method signature  to a synchronized block that wraps the creation of the MySingleton instance  But does this solve our problem  Well  we are no longer blocking on reads  but we   ve also taken a step backward  Multiple threads will hit the getInstance   method at or around the same time and they will all see the INSTANCE member as null  They will then hit the synchronized block where one will obtain the lock and create the instance  When that thread exits the block  the other threads will contend for the lock  and one by one each thread will fall through the block and create a new instance of our class  So we are right back where we started   private static MySingleton INSTANCE   public static MySingleton getInstance         if  INSTANCE    null            synchronized MySingleton class                if  INSTANCE    null                    INSTANCE   createInstance                                      return INSTANCE     Here we issue another check from inside the block  If the INSTANCE member has already been set  we   ll skip initialization  This is called double-checked locking  This solves our problem of multiple instantiation  But once again  our solution has presented another challenge  Other threads might not    see    that the INSTANCE member has been updated  This is because of how Java optimizes memory operations  Threads copy the original values of variables from main memory into the CPU   s cache  Changes to values are then written to  and read from  that cache  This is a feature of Java designed to optimize performance  But this creates a problem for our singleton implementation  A second thread     being processed by a different CPU or core  using a different cache     will not see the changes made by the first  This will cause the second thread to see the INSTANCE member as null forcing a new instance of our singleton to be created   private static volatile MySingleton INSTANCE   public static MySingleton getInstance         if  INSTANCE    null            synchronized MySingleton class                if  INSTANCE    null                    INSTANCE   createInstance                                      return INSTANCE     We solve this by using the volatile keyword on the declaration of the INSTANCE member  This will tell the compiler to always read from  and write to  main memory  and not the CPU cache  But this simple change comes at a cost  Because we are bypassing the CPU cache  we will take a performance hit each time we operate on the volatile INSTANCE member     which we do four times  We double-check existence  1 and 2   set the value  3   and then return the value  4   One could argue that this path is the fringe case as we only create the instance during the first call of the method  Perhaps a performance hit on creation is tolerable  But even our main use-case  reads  will operate on the volatile member twice  Once to check existence  and again to return its value   private static volatile MySingleton INSTANCE   public static MySingleton getInstance         MySingleton result   INSTANCE      if  result    null            synchronized MySingleton class                result   INSTANCE              if  result    null                    INSTANCE   result   createInstance                                      return result     Since the performance hit is due to operating directly on the volatile member  let   s set a local variable to the value of the volatile and operate on the local variable instead  This will decrease the number of times we operate on the volatile  thereby reclaiming some of our lost performance  Note that we have to set our local variable again when we enter the synchronized block  This ensures it is up to date with any changes that occurred while we were waiting for the lock  I wrote an article about this recently  Deconstructing The Singleton  You can find more information on these examples and an example of the  quot holder quot  pattern there  There is also a real-world example showcasing the double-checked volatile approach

User · Answer

I would say an enum singleton  Singleton using an enum in Java is generally a way to declare an enum singleton  An enum singleton may contain instance variables and instance methods  For simplicity s sake  also note that if you are using any instance method then you need to ensure thread safety of that method if at all it affects the state of object  The use of an enum is very easy to implement and has no drawbacks regarding serializable objects  which have to be circumvented in the other ways        Singleton pattern example using a Java Enum    public enum Singleton       INSTANCE      public void execute  String arg               Perform operation here          You can access it by Singleton INSTANCE  and it is much easier than calling the getInstance   method on Singleton   1 12    Serialization of Enum Constants Enum constants are serialized differently than ordinary serializable or externalizable objects  The serialized form of an enum constant consists solely of its name  field values of the constant are not present in the form  To serialize an enum constant  ObjectOutputStream writes the value returned by the enum constant s name method  To deserialize an enum constant  ObjectInputStream reads the constant name from the stream  the deserialized constant is then obtained by calling the java lang Enum valueOf method  passing the constant s enum type along with the received constant name as arguments  Like other serializable or externalizable objects  enum constants can function as the targets of back references appearing subsequently in the serialization stream  The process by which enum constants are serialized cannot be customized  any class-specific writeObject  readObject  readObjectNoData  writeReplace  and readResolve methods defined by enum types are ignored during serialization and deserialization  Similarly  any serialPersistentFields or serialVersionUID field declarations are also ignored--all enum types have a fixed serialVersionUID of 0L  Documenting serializable fields and data for enum types is unnecessary  since there is no variation in the type of data sent  Quoted from Oracle documentation  Another problem with conventional Singletons are that once you implement the Serializable interface  they no longer remain singleton because the readObject   method always return a new instance  like a constructor in Java  This can be avoided by using readResolve   and discarding the newly created instance by replacing with a singleton like below      readResolve to prevent another instance of Singleton  private Object readResolve         return INSTANCE      This can become even more complex if your singleton class maintains state  as you need to make them transient  but with in an enum singleton  serialization is guaranteed by the JVM   Good Read  Singleton Pattern Enums  Singletons and Deserialization Double-checked locking and the Singleton pattern

User · Answer

Disclaimer  I have just summarized all of the awesome answers and wrote it in my own words   While implementing Singleton we have two options   Lazy loading Early loading  Lazy loading adds bit overhead  lots of to be honest   so use it only when you have a very large object or heavy construction code and also have other accessible static methods or fields that might be used before an instance is needed  then and only then you need to use lazy initialization  Otherwise  choosing early loading is a good choice  The most simple way of implementing a singleton is  public class Foo           It will be our sole hero     private static final Foo INSTANCE   new Foo         private Foo             if  INSTANCE    null                   SHOUT             throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return INSTANCE           Everything is good except it s an early loaded singleton  Lets try lazy loaded singleton class Foo           Our now null but going to be sole hero     private static Foo INSTANCE   null       private Foo             if  INSTANCE    null                   SHOUT             throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance                Creating only  when required          if  INSTANCE    null                INSTANCE   new Foo                      return INSTANCE           So far so good  but our hero will not survive while fighting alone with multiple evil threads who want many many instance of our hero  So let   s protect it from evil multi threading  class Foo        private static Foo INSTANCE   null          TODO Add private shouting constructor      public static Foo getInstance                No more tension of threads         synchronized  Foo class                if  INSTANCE    null                    INSTANCE   new Foo                                    return INSTANCE           But it is not enough to protect out hero  really    This is the best we can should do to help our hero  class Foo           Pay attention to volatile     private static volatile Foo INSTANCE   null          TODO Add private shouting constructor      public static Foo getInstance             if  INSTANCE    null       Check 1             synchronized  Foo class                    if  INSTANCE    null       Check 2                     INSTANCE   new Foo                                                      return INSTANCE           This is called the  quot double-checked locking idiom quot   It s easy to forget the volatile statement and difficult to understand why it is necessary  For details  The  quot Double-Checked Locking is Broken quot  Declaration Now we are sure about evil threads  but what about the cruel serialization  We have to make sure even while de-serialiaztion no new object is created  class Foo implements Serializable        private static final long serialVersionUID   1L       private static volatile Foo INSTANCE   null          The rest of the things are same as above         No more fear of serialization      SuppressWarnings  quot unused quot       private Object readResolve             return INSTANCE           The method readResolve   will make sure the only instance will be returned  even when the object was serialized in a previous run of our program  Finally  we have added enough protection against threads and serialization  but our code is looking bulky and ugly  Let   s give our hero a makeover  public final class Foo implements Serializable        private static final long serialVersionUID   1L          Wrapped in a inner static class so that loaded only when required     private static class FooLoader               And no more fear of threads         private static final Foo INSTANCE   new Foo                  TODO add private shouting construcor      public static Foo getInstance             return FooLoader INSTANCE                Damn you serialization      SuppressWarnings  quot unused quot       private Foo readResolve             return FooLoader INSTANCE           Yes  this is our very same hero    Since the line private static final Foo INSTANCE   new Foo    is only executed when the class FooLoader is actually used  this takes care of the lazy instantiation  and is it guaranteed to be thread-safe  And we have come so far  Here is the best way to achieve everything we did is best possible way  public enum Foo       INSTANCE     Which internally will be treated like public class Foo           It will be our sole hero     private static final Foo INSTANCE   new Foo       That s it  No more fear of serialization  threads and ugly code  Also ENUMS singleton are lazily initialized   This approach is functionally equivalent to the public field approach  except that it is more concise  provides the serialization machinery for free  and provides an  ironclad guarantee against multiple instantiation  even in the face of sophisticated serialization or reflection attacks  While this approach has yet to be widely  adopted  a single-element enum type is the best way to implement a singleton   -Joshua Bloch in  quot Effective Java quot  Now you might have realized why ENUMS are considered as best way to implement a singleton and thanks for your patience    Updated it on my blog

User · Answer

I m mystified by some of the answers that suggest dependency injection  DI  as an alternative to using singletons  these are unrelated concepts  You can use DI to inject either singleton or non-singleton  e g   per-thread  instances  At least this is true if you use Spring 2 x  I can t speak for other DI frameworks  So my answer to the OP would be  in all but the most trivial sample code  to   Use a DI framework like Spring Framework  then Make it part of your DI configuration whether your dependencies are singletons  request scoped  session scoped  or whatever   This approach gives you a nice decoupled  and therefore flexible and testable  architecture where whether to use a singleton is an easily reversible implementation detail  provided any singletons you use are threadsafe  of course

User · Answer

Simplest singleton class  public class Singleton     private static Singleton singleInstance   new Singleton      private Singleton        public static Singleton getSingleInstance         return singleInstance

User · Answer

Sometimes a simple  static Foo foo   new Foo     is not enough  Just think of some basic data insertion you want to do   On the other hand you would have to synchronize any method that instantiates the singleton variable as such  Synchronisation is not bad as such  but it can lead to performance issues or locking  in very very rare situations using this example  The solution is  public class Singleton        private static Singleton instance   null       static             instance   new Singleton                 do some of your instantiation stuff here            private Singleton               if instance  null                      throw new ErrorYouWant  Singleton double-instantiation  should never happen                            public static getSingleton               return instance             Now what happens  The class is loaded via the class loader  Directly after the class was interpreted from a byte Array  the VM executes the static     - block  that s the whole secret  The static-block is only called once  the time the given class  name  of the given package is loaded by this one class loader

User · Answer

Following are three different approaches  Enum         Singleton pattern example using Java Enum      public enum EasySingleton        INSTANCE       Double checked locking   lazy loading         Singleton pattern example with Double checked Locking      public class DoubleCheckedLockingSingleton         private static volatile DoubleCheckedLockingSingleton INSTANCE         private DoubleCheckedLockingSingleton             public static DoubleCheckedLockingSingleton getInstance               if INSTANCE    null                 synchronized DoubleCheckedLockingSingleton class                        Double checking Singleton instance                  if INSTANCE    null                         INSTANCE   new DoubleCheckedLockingSingleton                                                            return INSTANCE               Static factory method         Singleton pattern example with static factory method       public class Singleton           Initialized during class loading      private static final Singleton INSTANCE   new Singleton             To prevent creating another instance of  Singleton       private Singleton            public static Singleton getSingleton              return INSTANCE

User · Answer

I m mystified by some of the answers that suggest dependency injection  DI  as an alternative to using singletons  these are unrelated concepts  You can use DI to inject either singleton or non-singleton  e g   per-thread  instances  At least this is true if you use Spring 2 x  I can t speak for other DI frameworks  So my answer to the OP would be  in all but the most trivial sample code  to   Use a DI framework like Spring Framework  then Make it part of your DI configuration whether your dependencies are singletons  request scoped  session scoped  or whatever   This approach gives you a nice decoupled  and therefore flexible and testable  architecture where whether to use a singleton is an easily reversible implementation detail  provided any singletons you use are threadsafe  of course

User · Answer

Disclaimer  I have just summarized all of the awesome answers and wrote it in my own words   While implementing Singleton we have two options   Lazy loading Early loading  Lazy loading adds bit overhead  lots of to be honest   so use it only when you have a very large object or heavy construction code and also have other accessible static methods or fields that might be used before an instance is needed  then and only then you need to use lazy initialization  Otherwise  choosing early loading is a good choice  The most simple way of implementing a singleton is  public class Foo           It will be our sole hero     private static final Foo INSTANCE   new Foo         private Foo             if  INSTANCE    null                   SHOUT             throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return INSTANCE           Everything is good except it s an early loaded singleton  Lets try lazy loaded singleton class Foo           Our now null but going to be sole hero     private static Foo INSTANCE   null       private Foo             if  INSTANCE    null                   SHOUT             throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance                Creating only  when required          if  INSTANCE    null                INSTANCE   new Foo                      return INSTANCE           So far so good  but our hero will not survive while fighting alone with multiple evil threads who want many many instance of our hero  So let   s protect it from evil multi threading  class Foo        private static Foo INSTANCE   null          TODO Add private shouting constructor      public static Foo getInstance                No more tension of threads         synchronized  Foo class                if  INSTANCE    null                    INSTANCE   new Foo                                    return INSTANCE           But it is not enough to protect out hero  really    This is the best we can should do to help our hero  class Foo           Pay attention to volatile     private static volatile Foo INSTANCE   null          TODO Add private shouting constructor      public static Foo getInstance             if  INSTANCE    null       Check 1             synchronized  Foo class                    if  INSTANCE    null       Check 2                     INSTANCE   new Foo                                                      return INSTANCE           This is called the  quot double-checked locking idiom quot   It s easy to forget the volatile statement and difficult to understand why it is necessary  For details  The  quot Double-Checked Locking is Broken quot  Declaration Now we are sure about evil threads  but what about the cruel serialization  We have to make sure even while de-serialiaztion no new object is created  class Foo implements Serializable        private static final long serialVersionUID   1L       private static volatile Foo INSTANCE   null          The rest of the things are same as above         No more fear of serialization      SuppressWarnings  quot unused quot       private Object readResolve             return INSTANCE           The method readResolve   will make sure the only instance will be returned  even when the object was serialized in a previous run of our program  Finally  we have added enough protection against threads and serialization  but our code is looking bulky and ugly  Let   s give our hero a makeover  public final class Foo implements Serializable        private static final long serialVersionUID   1L          Wrapped in a inner static class so that loaded only when required     private static class FooLoader               And no more fear of threads         private static final Foo INSTANCE   new Foo                  TODO add private shouting construcor      public static Foo getInstance             return FooLoader INSTANCE                Damn you serialization      SuppressWarnings  quot unused quot       private Foo readResolve             return FooLoader INSTANCE           Yes  this is our very same hero    Since the line private static final Foo INSTANCE   new Foo    is only executed when the class FooLoader is actually used  this takes care of the lazy instantiation  and is it guaranteed to be thread-safe  And we have come so far  Here is the best way to achieve everything we did is best possible way  public enum Foo       INSTANCE     Which internally will be treated like public class Foo           It will be our sole hero     private static final Foo INSTANCE   new Foo       That s it  No more fear of serialization  threads and ugly code  Also ENUMS singleton are lazily initialized   This approach is functionally equivalent to the public field approach  except that it is more concise  provides the serialization machinery for free  and provides an  ironclad guarantee against multiple instantiation  even in the face of sophisticated serialization or reflection attacks  While this approach has yet to be widely  adopted  a single-element enum type is the best way to implement a singleton   -Joshua Bloch in  quot Effective Java quot  Now you might have realized why ENUMS are considered as best way to implement a singleton and thanks for your patience    Updated it on my blog

User · Answer

You need the double-checking idiom if you need to load the instance variable of a class lazily  If you need to load a static variable or a singleton lazily  you need the initialization on demand holder idiom  In addition  if the singleton needs to be serializable  all other fields need to be transient and readResolve   method needs to be implemented in order to maintain the singleton object invariant  Otherwise  each time the object is deserialized  a new instance of the object will be created  What readResolve   does is replace the new object read by readObject    which forced that new object to be garbage collected as there is no variable referring to it  public static final INSTANCE         private Object readResolve       return INSTANCE     Original singleton instance

User · Answer

Have a look at this post  Examples of GoF Design Patterns in Java  39 s core libraries From the best answer s  quot Singleton quot  section   Singleton  recognizeable by creational methods returning the same instance  usually of itself  everytime   java lang Runtime getRuntime   java awt Desktop getDesktop   java lang System getSecurityManager     You can also learn the example of Singleton from Java native classes themselves

User · Answer

Wikipedia has some examples of singletons  also in Java  The Java 5 implementation looks pretty complete  and is thread-safe  double-checked locking applied

User · Answer

I use the Spring Framework to manage my singletons  It doesn t enforce the  quot singleton-ness quot  of the class  which you can t really do anyway if there are multiple class loaders involved   but it provides a really easy way to build and configure different factories for creating different types of objects

User · Answer

This is how to implement a simple singleton  public class Singleton          It must be static and final to prevent later modification     private static final Singleton INSTANCE   new Singleton            The constructor must be private to prevent external instantiation        private Singleton             The public static method allowing to get the instance        public static Singleton getInstance             return INSTANCE           This is how to properly lazy create your singleton  public class Singleton          The constructor must be private to prevent external instantiation     private Singleton             The public static method allowing to get the instance        public static Singleton getInstance             return SingletonHolder INSTANCE                       The static inner class responsible for creating your instance only on demand         because the static fields of a class are only initialized when the class        is explicitly called and a class initialization is synchronized such that only        one thread can perform it  this rule is also applicable to inner static class        So here INSTANCE will be created only when SingletonHolder INSTANCE        will be called             private static class SingletonHolder           private static final Singleton INSTANCE   new Singleton

User · Answer

Enum singleton The simplest way to implement a singleton that is thread-safe is using an Enum  public enum SingletonEnum     INSTANCE    public void doSomething        System out println  quot This is a singleton quot           This code works since the introduction of Enum in Java 1 5 Double checked locking If you want to code a    classic    singleton that works in a multithreaded environment  starting from Java 1 5  you should use this one  public class Singleton      private static volatile Singleton instance   null     private Singleton            public static Singleton getInstance         if  instance    null          synchronized  Singleton class           if  instance    null              instance   new Singleton                                return instance         This is not thread-safe before 1 5 because the implementation of the volatile keyword was different  Early loading singleton  works even before Java 1 5  This implementation instantiates the singleton when the class is loaded and provides thread safety  public class Singleton      private static final Singleton instance   new Singleton       private Singleton            public static Singleton getInstance         return instance         public void doSomething        System out println  quot This is a singleton quot

User · Answer

The solution posted by Stu Thompson is valid in Java  5 0 and later  But I would prefer not to use it because I think it is error prone  It s easy to forget the volatile statement and difficult to understand why it is necessary  Without the volatile this code would not be thread safe any more due to the double-checked locking antipattern  See more about this in paragraph 16 2 4 of Java Concurrency in Practice  In short  This pattern  prior to Java  5 0 or without the volatile statement  could return a reference to the Bar object that is  still  in an incorrect state  This pattern was invented for performance optimization  But this is really not a real concern any more  The following lazy initialization code is fast and - more importantly - easier to read  class Bar       private static class BarHolder           public static Bar bar   new Bar               public static Bar getBar             return BarHolder bar

User · Answer

Depending on the usage  there are several  quot correct quot  answers  Since Java 5  the best way to do it is to use an enum  public enum Foo      INSTANCE     Pre Java 5  the most simple case is  public final class Foo        private static final Foo INSTANCE   new Foo         private Foo             if  INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return INSTANCE             public Object clone   throws CloneNotSupportedException          throw new CloneNotSupportedException  quot Cannot clone instance of this class quot             Let s go over the code  First  you want the class to be final  In this case  I ve used the final keyword to let the users know it is final  Then you need to make the constructor private to prevent users to create their own Foo  Throwing an exception from the constructor prevents users to use reflection to create a second Foo  Then you create a private static final Foo field to hold the only instance  and a public static Foo getInstance   method to return it  The Java specification makes sure that the constructor is only called when the class is first used  When you have a very large object or heavy construction code and also have other accessible static methods or fields that might be used before an instance is needed  then and only then you need to use lazy initialization  You can use a private static class to load the instance  The code would then look like  public final class Foo        private static class FooLoader           private static final Foo INSTANCE   new Foo               private Foo             if  FooLoader INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return FooLoader INSTANCE           Since the line private static final Foo INSTANCE   new Foo    is only executed when the class FooLoader is actually used  this takes care of the lazy instantiation  and is it guaranteed to be thread safe  When you also want to be able to serialize your object you need to make sure that deserialization won t create a copy  public final class Foo implements Serializable        private static final long serialVersionUID   1L       private static class FooLoader           private static final Foo INSTANCE   new Foo               private Foo             if  FooLoader INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return FooLoader INSTANCE              SuppressWarnings  quot unused quot       private Foo readResolve             return FooLoader INSTANCE           The method readResolve   will make sure the only instance will be returned  even when the object was serialized in a previous run of your program

User · Answer

Version 1   public class MySingleton       private static MySingleton instance   null      private MySingleton          public static synchronized MySingleton getInstance             if instance    null                instance   new MySingleton                      return instance            Lazy loading  thread safe with blocking  low performance because of synchronized   Version 2   public class MySingleton       private MySingleton          private static class MySingletonHolder           public final static MySingleton instance   new MySingleton              public static MySingleton getInstance             return MySingletonHolder instance            Lazy loading  thread safe with non-blocking  high performance

User · Answer

Thread safe in Java 5   class Foo       private static volatile Bar bar   null      public static Bar getBar             if  bar    null                synchronized Foo class                    if  bar    null                      bar   new Bar                                    return bar            Pay attention to the volatile modifier here     It is important because without it  other threads are not guaranteed by the JMM  Java Memory Model  to see changes to its value   The synchronization does not take care of that--it only serializes access to that block of code   Bno s answer details the approach recommended by Bill Pugh  FindBugs  and is arguable better   Go read and vote up his answer too

User · Answer

Simplest singleton class  public class Singleton     private static Singleton singleInstance   new Singleton      private Singleton        public static Singleton getSingleInstance         return singleInstance

User · Answer

Another argument often used against singletons is their testability problems  Singletons are not easily mockable for testing purposes  If this turns out to be a problem  I like to make the following slight modification  public class SingletonImpl        private static SingletonImpl instance       public static SingletonImpl getInstance             if  instance    null                instance   new SingletonImpl                      return instance             public static void setInstance SingletonImpl impl            instance   impl             public void a             System out println  quot Default Method quot             The added setInstance method allows setting a mockup implementation of the singleton class during testing  public class SingletonMock extends SingletonImpl         Override     public void a             System out println  quot Mock Method quot              This also works with early initialization approaches  public class SingletonImpl        private static final SingletonImpl instance   new SingletonImpl         private static SingletonImpl alt       public static void setInstance SingletonImpl inst            alt   inst             public static SingletonImpl getInstance             if  alt    null                return alt                    return instance             public void a             System out println  quot Default Method quot             public class SingletonMock extends SingletonImpl         Override     public void a             System out println  quot Mock Method quot              This has the drawback of exposing this functionality to the normal application too  Other developers working on that code could be tempted to use the   setInstance   method to alter a specific function and thus changing the whole application behaviour  and therefore this method should contain at least a good warning in its javadoc  Still  for the possibility of mockup-testing  when needed   this code exposure may be an acceptable price to pay

User · Answer

There are four ways to create a singleton in Java   Eager initialization singleton  public class Test        private static final Test test   new Test          private Test                  public static Test getTest              return test              Lazy initialization singleton  thread safe   public class Test         private static volatile Test test         private Test                    public static Test getTest              if test    null                 synchronized Test class                     if test    null                         test   new Test                                                          return test              Bill Pugh singleton with holder pattern  preferably the best one   public class Test         private Test                  private static class TestHolder            private static final Test test   new Test                 public static Test getInstance              return TestHolder test              Enum singleton  public enum MySingleton        INSTANCE        private MySingleton              System out println  quot Here quot

User · Answer

The solution posted by Stu Thompson is valid in Java  5 0 and later  But I would prefer not to use it because I think it is error prone  It s easy to forget the volatile statement and difficult to understand why it is necessary  Without the volatile this code would not be thread safe any more due to the double-checked locking antipattern  See more about this in paragraph 16 2 4 of Java Concurrency in Practice  In short  This pattern  prior to Java  5 0 or without the volatile statement  could return a reference to the Bar object that is  still  in an incorrect state  This pattern was invented for performance optimization  But this is really not a real concern any more  The following lazy initialization code is fast and - more importantly - easier to read  class Bar       private static class BarHolder           public static Bar bar   new Bar               public static Bar getBar             return BarHolder bar

User · Answer

Depending on the usage  there are several  quot correct quot  answers  Since Java 5  the best way to do it is to use an enum  public enum Foo      INSTANCE     Pre Java 5  the most simple case is  public final class Foo        private static final Foo INSTANCE   new Foo         private Foo             if  INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return INSTANCE             public Object clone   throws CloneNotSupportedException          throw new CloneNotSupportedException  quot Cannot clone instance of this class quot             Let s go over the code  First  you want the class to be final  In this case  I ve used the final keyword to let the users know it is final  Then you need to make the constructor private to prevent users to create their own Foo  Throwing an exception from the constructor prevents users to use reflection to create a second Foo  Then you create a private static final Foo field to hold the only instance  and a public static Foo getInstance   method to return it  The Java specification makes sure that the constructor is only called when the class is first used  When you have a very large object or heavy construction code and also have other accessible static methods or fields that might be used before an instance is needed  then and only then you need to use lazy initialization  You can use a private static class to load the instance  The code would then look like  public final class Foo        private static class FooLoader           private static final Foo INSTANCE   new Foo               private Foo             if  FooLoader INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return FooLoader INSTANCE           Since the line private static final Foo INSTANCE   new Foo    is only executed when the class FooLoader is actually used  this takes care of the lazy instantiation  and is it guaranteed to be thread safe  When you also want to be able to serialize your object you need to make sure that deserialization won t create a copy  public final class Foo implements Serializable        private static final long serialVersionUID   1L       private static class FooLoader           private static final Foo INSTANCE   new Foo               private Foo             if  FooLoader INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return FooLoader INSTANCE              SuppressWarnings  quot unused quot       private Foo readResolve             return FooLoader INSTANCE           The method readResolve   will make sure the only instance will be returned  even when the object was serialized in a previous run of your program

User · Answer

Make sure that you really need it  Do a google search for  quot singleton anti-pattern quot  to see some arguments against it  There s nothing inherently wrong with it I suppose  but it s just a mechanism for exposing some global resource data so make sure that this is the best way  In particular  I ve found dependency injection  DI  more useful particularly if you are also using unit tests  because DI allows you to use mocked resources for testing purposes

User · Answer

I would say an enum singleton  Singleton using an enum in Java is generally a way to declare an enum singleton  An enum singleton may contain instance variables and instance methods  For simplicity s sake  also note that if you are using any instance method then you need to ensure thread safety of that method if at all it affects the state of object  The use of an enum is very easy to implement and has no drawbacks regarding serializable objects  which have to be circumvented in the other ways        Singleton pattern example using a Java Enum    public enum Singleton       INSTANCE      public void execute  String arg               Perform operation here          You can access it by Singleton INSTANCE  and it is much easier than calling the getInstance   method on Singleton   1 12    Serialization of Enum Constants Enum constants are serialized differently than ordinary serializable or externalizable objects  The serialized form of an enum constant consists solely of its name  field values of the constant are not present in the form  To serialize an enum constant  ObjectOutputStream writes the value returned by the enum constant s name method  To deserialize an enum constant  ObjectInputStream reads the constant name from the stream  the deserialized constant is then obtained by calling the java lang Enum valueOf method  passing the constant s enum type along with the received constant name as arguments  Like other serializable or externalizable objects  enum constants can function as the targets of back references appearing subsequently in the serialization stream  The process by which enum constants are serialized cannot be customized  any class-specific writeObject  readObject  readObjectNoData  writeReplace  and readResolve methods defined by enum types are ignored during serialization and deserialization  Similarly  any serialPersistentFields or serialVersionUID field declarations are also ignored--all enum types have a fixed serialVersionUID of 0L  Documenting serializable fields and data for enum types is unnecessary  since there is no variation in the type of data sent  Quoted from Oracle documentation  Another problem with conventional Singletons are that once you implement the Serializable interface  they no longer remain singleton because the readObject   method always return a new instance  like a constructor in Java  This can be avoided by using readResolve   and discarding the newly created instance by replacing with a singleton like below      readResolve to prevent another instance of Singleton  private Object readResolve         return INSTANCE      This can become even more complex if your singleton class maintains state  as you need to make them transient  but with in an enum singleton  serialization is guaranteed by the JVM   Good Read  Singleton Pattern Enums  Singletons and Deserialization Double-checked locking and the Singleton pattern

User · Answer

Use an enum   public enum Foo       INSTANCE      Joshua Bloch explained this approach in his Effective Java Reloaded talk at Google I O 2008  link to video  Also see slides 30-32 of his presentation  effective java reloaded pdf       The Right Way to Implement a Serializable Singleton  public enum Elvis       INSTANCE      private final String   favoriteSongs              Hound Dog    Heartbreak Hotel         public void printFavorites             System out println Arrays toString favoriteSongs               Edit  An online portion of  Effective Java  says        This approach is functionally equivalent to the public field approach  except that it is more concise  provides the serialization machinery for free  and provides an ironclad guarantee against multiple instantiation  even in the face of sophisticated serialization or reflection attacks  While this approach has yet to be widely adopted  a single-element enum type is the best way to implement a singleton

User · Answer

Really consider why you need a singleton before writing it  There is a quasi-religious debate about using them which you can quite easily stumble over if you google singletons in Java  Personally  I try to avoid singletons as often as possible for many reasons  again most of which can be found by googling singletons  I feel that quite often singletons are abused because they re easy to understand by everybody  They re used as a mechanism for getting  quot global quot  data into an OO design and they are used because it is easy to circumvent object lifecycle management  or really thinking about how you can do A from inside B   Look at things like inversion of control  IoC  or dependency injection  DI  for a nice middle ground  If you really need one then Wikipedia has a good example of a proper implementation of a singleton

User · Answer

Wikipedia has some examples of singletons  also in Java  The Java 5 implementation looks pretty complete  and is thread-safe  double-checked locking applied

User · Answer

I use the Spring Framework to manage my singletons  It doesn t enforce the  quot singleton-ness quot  of the class  which you can t really do anyway if there are multiple class loaders involved   but it provides a really easy way to build and configure different factories for creating different types of objects

User · Answer

Sometimes a simple  static Foo foo   new Foo     is not enough  Just think of some basic data insertion you want to do   On the other hand you would have to synchronize any method that instantiates the singleton variable as such  Synchronisation is not bad as such  but it can lead to performance issues or locking  in very very rare situations using this example  The solution is  public class Singleton        private static Singleton instance   null       static             instance   new Singleton                 do some of your instantiation stuff here            private Singleton               if instance  null                      throw new ErrorYouWant  Singleton double-instantiation  should never happen                            public static getSingleton               return instance             Now what happens  The class is loaded via the class loader  Directly after the class was interpreted from a byte Array  the VM executes the static     - block  that s the whole secret  The static-block is only called once  the time the given class  name  of the given package is loaded by this one class loader

User · Answer

The solution posted by Stu Thompson is valid in Java  5 0 and later  But I would prefer not to use it because I think it is error prone  It s easy to forget the volatile statement and difficult to understand why it is necessary  Without the volatile this code would not be thread safe any more due to the double-checked locking antipattern  See more about this in paragraph 16 2 4 of Java Concurrency in Practice  In short  This pattern  prior to Java  5 0 or without the volatile statement  could return a reference to the Bar object that is  still  in an incorrect state  This pattern was invented for performance optimization  But this is really not a real concern any more  The following lazy initialization code is fast and - more importantly - easier to read  class Bar       private static class BarHolder           public static Bar bar   new Bar               public static Bar getBar             return BarHolder bar

User · Answer

I m mystified by some of the answers that suggest dependency injection  DI  as an alternative to using singletons  these are unrelated concepts  You can use DI to inject either singleton or non-singleton  e g   per-thread  instances  At least this is true if you use Spring 2 x  I can t speak for other DI frameworks  So my answer to the OP would be  in all but the most trivial sample code  to   Use a DI framework like Spring Framework  then Make it part of your DI configuration whether your dependencies are singletons  request scoped  session scoped  or whatever   This approach gives you a nice decoupled  and therefore flexible and testable  architecture where whether to use a singleton is an easily reversible implementation detail  provided any singletons you use are threadsafe  of course

User · Answer

For JSE 5 0 and above  take the Enum approach  Otherwise  use the static singleton holder approach   a lazy loading approach described by Bill Pugh   The latter solution is also thread-safe without requiring special language constructs  i e   volatile or synchronized

User · Answer

Really consider why you need a singleton before writing it  There is a quasi-religious debate about using them which you can quite easily stumble over if you google singletons in Java  Personally  I try to avoid singletons as often as possible for many reasons  again most of which can be found by googling singletons  I feel that quite often singletons are abused because they re easy to understand by everybody  They re used as a mechanism for getting  quot global quot  data into an OO design and they are used because it is easy to circumvent object lifecycle management  or really thinking about how you can do A from inside B   Look at things like inversion of control  IoC  or dependency injection  DI  for a nice middle ground  If you really need one then Wikipedia has a good example of a proper implementation of a singleton

User · Answer

Wikipedia has some examples of singletons  also in Java  The Java 5 implementation looks pretty complete  and is thread-safe  double-checked locking applied

User · Answer

Make sure that you really need it  Do a google search for  quot singleton anti-pattern quot  to see some arguments against it  There s nothing inherently wrong with it I suppose  but it s just a mechanism for exposing some global resource data so make sure that this is the best way  In particular  I ve found dependency injection  DI  more useful particularly if you are also using unit tests  because DI allows you to use mocked resources for testing purposes

User · Answer

Depending on the usage  there are several  quot correct quot  answers  Since Java 5  the best way to do it is to use an enum  public enum Foo      INSTANCE     Pre Java 5  the most simple case is  public final class Foo        private static final Foo INSTANCE   new Foo         private Foo             if  INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return INSTANCE             public Object clone   throws CloneNotSupportedException          throw new CloneNotSupportedException  quot Cannot clone instance of this class quot             Let s go over the code  First  you want the class to be final  In this case  I ve used the final keyword to let the users know it is final  Then you need to make the constructor private to prevent users to create their own Foo  Throwing an exception from the constructor prevents users to use reflection to create a second Foo  Then you create a private static final Foo field to hold the only instance  and a public static Foo getInstance   method to return it  The Java specification makes sure that the constructor is only called when the class is first used  When you have a very large object or heavy construction code and also have other accessible static methods or fields that might be used before an instance is needed  then and only then you need to use lazy initialization  You can use a private static class to load the instance  The code would then look like  public final class Foo        private static class FooLoader           private static final Foo INSTANCE   new Foo               private Foo             if  FooLoader INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return FooLoader INSTANCE           Since the line private static final Foo INSTANCE   new Foo    is only executed when the class FooLoader is actually used  this takes care of the lazy instantiation  and is it guaranteed to be thread safe  When you also want to be able to serialize your object you need to make sure that deserialization won t create a copy  public final class Foo implements Serializable        private static final long serialVersionUID   1L       private static class FooLoader           private static final Foo INSTANCE   new Foo               private Foo             if  FooLoader INSTANCE    null                throw new IllegalStateException  quot Already instantiated quot                         public static Foo getInstance             return FooLoader INSTANCE              SuppressWarnings  quot unused quot       private Foo readResolve             return FooLoader INSTANCE           The method readResolve   will make sure the only instance will be returned  even when the object was serialized in a previous run of your program

User · Answer

Various ways to make a singleton object   As per Joshua Bloch - Enum would be the best   You can use double check locking also   Even an inner static class can be used

User · Answer

The solution posted by Stu Thompson is valid in Java  5 0 and later  But I would prefer not to use it because I think it is error prone  It s easy to forget the volatile statement and difficult to understand why it is necessary  Without the volatile this code would not be thread safe any more due to the double-checked locking antipattern  See more about this in paragraph 16 2 4 of Java Concurrency in Practice  In short  This pattern  prior to Java  5 0 or without the volatile statement  could return a reference to the Bar object that is  still  in an incorrect state  This pattern was invented for performance optimization  But this is really not a real concern any more  The following lazy initialization code is fast and - more importantly - easier to read  class Bar       private static class BarHolder           public static Bar bar   new Bar               public static Bar getBar             return BarHolder bar

User · Answer

If you do not need lazy loading then simply try  public class Singleton       private final static Singleton INSTANCE   new Singleton         private Singleton           public static Singleton getInstance     return Singleton INSTANCE         protected Object clone             throw new CloneNotSupportedException             If you want lazy loading and you want your singleton to be thread-safe  try the double-checking pattern  public class Singleton       private static Singleton instance   null       private Singleton           public static Singleton getInstance             if null    instance                synchronized Singleton class                    if null    instance                        instance   new Singleton                                                      return instance             protected Object clone             throw new CloneNotSupportedException             As the double checking pattern is not guaranteed to work  due to some issue with compilers  I don t know anything more about that   you could also try to synchronize the whole getInstance-method or create a registry for all your singletons

User · Answer

Sometimes a simple  static Foo foo   new Foo     is not enough  Just think of some basic data insertion you want to do   On the other hand you would have to synchronize any method that instantiates the singleton variable as such  Synchronisation is not bad as such  but it can lead to performance issues or locking  in very very rare situations using this example  The solution is  public class Singleton        private static Singleton instance   null       static             instance   new Singleton                 do some of your instantiation stuff here            private Singleton               if instance  null                      throw new ErrorYouWant  Singleton double-instantiation  should never happen                            public static getSingleton               return instance             Now what happens  The class is loaded via the class loader  Directly after the class was interpreted from a byte Array  the VM executes the static     - block  that s the whole secret  The static-block is only called once  the time the given class  name  of the given package is loaded by this one class loader

User · Answer

The best singleton pattern I ve ever seen uses the Supplier interface    It s generic and reusable It supports lazy initialization It s only synchronized until it has been initialized  then the blocking supplier is replaced with a non-blocking supplier    See below   public class Singleton lt T gt  implements Supplier lt T gt         private boolean initialized      private Supplier lt T gt  singletonSupplier       public Singleton T singletonValue            this singletonSupplier      - gt  singletonValue             public Singleton Supplier lt T gt  supplier            this singletonSupplier      - gt                   The initial supplier is temporary  it will be replaced after initialization             synchronized  supplier                    if   initialized                        T singletonValue   supplier get                           Now that the singleton value has been initialized                         replace the blocking supplier with a non-blocking supplier                     singletonSupplier      - gt  singletonValue                      initialized   true                                    return singletonSupplier get                                         Override     public T get             return singletonSupplier get

[java] What is an efficient way to implement a singleton pattern in Java?

Examples related to java

Examples related to singleton

Examples related to design-patterns