Difference between static class and singleton pattern?

Asked 2023-09-20 20:59:34 View 388,803

What real (i.e. practical) difference exists between a static class and a singleton pattern?

Both can be invoked without instantiation, both provide only one "Instance" and neither of them is thread-safe. Is there any other difference?

Answers

What makes you say that either a singleton or a static method isn't thread-safe? Usually both should be implemented to be thread-safe.

The big difference between a singleton and a bunch of static methods is that singletons can implement interfaces (or derive from useful base classes, although that's less common, in my experience), so you can pass around the singleton as if it were "just another" implementation.

Answered   2023-09-20 20:59:34

  • Well, if you prefer it, neither is inherently threadsafe, you have to make them be threadsafe, both of them, so no difference there. - anyone
  • Can you give an example of something which is inherently threadsafe, other than immutable types? - anyone
  • To Skeet: People saying that singleton isn't threadsafe mean that a singleton is shared between threads unnecessarily all the time, while stack objects get shared when you need them to, which means you don't have to do unneeded synchronization. - anyone
  • @Geek: Imagine the singleton implements an interface Foo, and you have a method taking a Foo as a parameter. With that setup, callers can choose to use the singleton as the implementation - or they could use a different implementation. The method is decoupled from the singleton. Compare that with the situation where the class just has static methods - every piece of code which wants to call those methods is tightly coupled to the class, because it needs to specify which class contains the static methods. - anyone
  • @AmirBareket: It's not a singleton according to the singleton design pattern though - if the class itself allows multiple instances to be created, it's not a singleton IMO, regardless of what the factory does. - anyone

The true answer is by Jon Skeet, on another forum here.

A singleton allows access to a single created instance - that instance (or rather, a reference to that instance) can be passed as a parameter to other methods, and treated as a normal object.

A static class allows only static methods.

Answered   2023-09-20 20:59:34

  • Why would you pass a Singleton as a parameter, though, if you can access the same instance from just about anywhere by calling the static getInstance() method? - anyone
  • @HenriqueOrdine So it can fit into existing code and provide an interface? - anyone
  • @HenriqueOrdine They are speaking about static class, not a class with static methods. Static class cannot be instantiated. Nevertheless, if you pass an instance of a (non-static)class that contains static methods, you cannot call static methods on an instance. - anyone
  • What's a static class? At least in Java, there's no such thing. - anyone
  • @Goran I was initially very confused by your wording. You said "you cannot call static methods on an instance". I read that as "if you have a reference to an instantiated object, you cannot call any static methods it may have." That is of course, incorrect. After reading it again a few times I think you meant "from inside static methods you cannot access non-static objects in the class" which is correct. Want to clarify that for anyone new to these concepts who comes across this answer and reads your comments. - anyone
  1. Singleton objects are stored in Heap, but static objects are stored in stack.
  2. We can clone (if the designer did not disallow it) the singleton object, but we can not clone the static class object .
  3. Singleton classes follow the OOP (object oriented principles), static classes do not.
  4. We can implement an interface with a Singleton class, but a class's static methods (or e.g. a C# static class) cannot.

Answered   2023-09-20 20:59:34

  • The second statement is wrong. We can't clone Singleton object. Singleton implementation must refuse this. If you really can clone Singleton, it's not Singleton. - anyone
  • This is answer is not correct for Java: neither the singleton nor the static uses the stack. - anyone
  • #1 is not important. #2 describes a defective implementation. #3 is completely unjustifiable. - anyone
  • How can static object be stored in stack? New stack frame is created when you invoke a method, it stores method's local variables, this stack frame is removed when the method returns, and those local variables are lost. Sure stack is fast, but it is not suitable to store static objects. - anyone
  • I cannot understand the number of upvotes on this one. 1) Why should Singleton have to be stored in stack? In managed languages like C# or Java data is stored in a managed heap, except for local method variables/parameters. 2) If you can clone it, then it's not a properly implemented singleton. 3) Singleton is known as a OOP anti-pattern; i.e. something that you should avoid if possible. 4) This is the only thing that's correct. - anyone

The Singleton pattern has several advantages over static classes. First, a singleton can extend classes and implement interfaces, while a static class cannot (it can extend classes, but it does not inherit their instance members). A singleton can be initialized lazily or asynchronously while a static class is generally initialized when it is first loaded, leading to potential class loader issues. However the most important advantage, though, is that singletons can be handled polymorphically without forcing their users to assume that there is only one instance.

Answered   2023-09-20 20:59:34

  • +1 for good, pragmatic points. Singleton pattern is overused in general, but there are a few situations where it is fitting. See also: agiletribe.wordpress.com/2013/10/08/… - anyone
  • You are right about advantage of being polymorphic. This is the most important point - anyone
  • Nested static class can implement interface. Try coding it, will work. I could compile the code without any error. - anyone

static classes are not for anything that needs state. It is useful for putting a bunch of functions together i.e Math (or Utils in projects). So the class name just gives us a clue where we can find the functions and nothing more.

Singleton is my favorite pattern and I use it to manage something at a single point. It's more flexible than static classes and can maintain it's state. It can implement interfaces, inherit from other classes and allow inheritance.

My rule for choosing between static and singleton:

If there is a bunch of functions that should be kept together, then static is the choice. Anything else which needs single access to some resources, could be implemented as a singleton.

Answered   2023-09-20 20:59:34

  • Why should static classes not do anything which needs to save state? - anyone
  • @Trisped: You have neither precise control over initialization nor finalization. - anyone
  • you lost me at "Singleton is my favorite pattern". Singleton is such a sharp corner that it should be considered an anti-pattern as well as a pattern. Classes can well have static states, that's also single access, if anything static state is more "single access" than singletons because most singleton implementations are broken ie. you can clone the singleton, while static is blessed by the definition to be unique. - anyone
  • What does it mean to maintain state? What is state? - anyone
  • @KyleDelaney: Simply State is the combination of different properties of an object which usually change over time. You can Google for formal definition. - anyone

Static Class:-

  1. You cannot create the instance of static class.

  2. Loaded automatically by the .NET Framework common language runtime (CLR) when the program or namespace containing the class is loaded.

  3. We cannot pass the static class to method.

  4. We cannot inherit Static class to another Static class in C#.

  5. A class having all static methods.

  6. Better performance (static methods are bonded on compile time)

Singleton:-

  1. You can create one instance of the object and reuse it.

  2. Singleton instance is created for the first time when the user requested.

  3. You can create the object of singleton class and pass it to method.

  4. Singleton class does not say any restriction of Inheritance.

  5. We can dispose the objects of a singleton class but not of static class.

  6. Methods can be overridden.

  7. Can be lazy loaded when need (static classes are always loaded).

  8. We can implement interface(static class can not implement interface).

Answered   2023-09-20 20:59:34

  • Static classes do have constructors: msdn.microsoft.com/en-us/library/k9x6w0hc.aspx - anyone
  • Yes, static can have constructor which is internal to that class. This gets invoked when any static method in the class is called. - anyone
  • For singleton on compile time, it is stored in the HEAP memory but if it gets instantiated once does it get stored in STACK? - anyone
  • @Luminous_Dev No. Any singleton instance is an object instance at the end of the day. It will get stored on heap without doubt. - anyone
  • @rahulmr Important distinction: the constructor also gets invoked before the first (AKA only) instance is created. - anyone

A static class is one that has only static methods, for which a better word would be "functions". The design style embodied in a static class is purely procedural.

Singleton, on the other hand, is a pattern specific to OO design. It is an instance of an object (with all the possibilities inherent in that, such as polymorphism), with a creation procedure that ensures that there is only ever one instance of that particular role over its entire lifetime.

Answered   2023-09-20 20:59:34

  • polymorphism doesn't come into play with singletons at all - anyone
  • So you think. I think differently. ;) For instance, imagine a singleton factory that returns an interface. You know you're getting an ISingleton (and it's the same one forever) but not necessarily which implementation. - anyone
  • Nested static class can have instance methods as well, its not restricted to have only static methods.. Code it and you can see. - anyone
  • In languages with a nicer object model (e.g. Ruby), classes are objects too. The "purely procedural" aspect of a static class is an arbitrary restriction imposed by the language. - anyone

In singleton pattern you can create the singleton as an instance of a derived type, you can't do that with a static class.

Quick Example:

if( useD3D )
    IRenderer::instance = new D3DRenderer
else
    IRenderer::instance = new OpenGLRenderer

Answered   2023-09-20 20:59:34

  • It's not really a singleton pattern, looks more like factory to me. - anyone
  • Not really, the fundamental difference between the two is that the Singleton will "cache" its single object and keep returning (a reference to) the same one. The Factory pattern will create new instances. - anyone
  • Then it's proxy-singleton :) - anyone
  • Hmm, I know this variety of the Singleton as MonoState. - anyone
  • example is factory pattern - anyone

To expand on Jon Skeet's Answer

The big difference between a singleton and a bunch of static methods is that singletons can implement interfaces (or derive from useful base classes, although that's less common IME), so you can pass around the singleton as if it were "just another" implementation.

Singletons are easier to work with when unit testing a class. Wherever you pass singletons as a parameter (constructors, setters or methods) you can instead substitute a mocked or stubbed version of the singleton.

Answered   2023-09-20 20:59:34

  • I don't think you can directly mock a singleton. Wouldn't you have to declare an interface that the singleton and the mock class both implement? - anyone
  • @espertus Why cant you mock your singleton? Example using mockito MySingleton mockOfMySingleton = mock(MySingleton.class). - anyone
  • you're right, you can mock it with tools like mockito that use reflection. I meant that you can't mock it directly by subclassing it and overriding its methods. - anyone
  • @espertus Why not? When you instantiate the object you are testing you can substitute the subclass implementation of your singleton wherever you would have used the original. Ex: new ClazzToTest(mockSingleton); - anyone
  • I haven't used Mockito, but how can you subclass a class that has a private constructor, which is the case for singletons, except by using reflection? Related discussions: stackoverflow.com/questions/2302179/mocking-a-singleton-class stackoverflow.com/questions/15939023/… - anyone

Here's a good article: http://javarevisited.blogspot.com.au/2013/03/difference-between-singleton-pattern-vs-static-class-java.html

Static classes

  • a class having all static methods.
  • better performance (static methods are bonded on compile time)
  • can't override methods, but can use method hiding. (What is method hiding in Java? Even the JavaDoc explanation is confusing)

    public class Animal {
        public static void foo() {
            System.out.println("Animal");
        }
    }
    
    public class Cat extends Animal {
        public static void foo() {  // hides Animal.foo()
            System.out.println("Cat");
        }
    }
    

Singleton

In summary, I would only use static classes for holding util methods, and using Singleton for everything else.


Edits

Answered   2023-09-20 20:59:34

  • I don't know about java, but in .Net, your last two points are incorrect. Static classes can reference static properies and fields, so on state they are equal. And they are lazy loaded -- the static constructor is run when: 1) An instance of the class is created. 2) Any of the static members of the class are referenced. 1 doesn't apply, which leaves 2. So, a static class is not loaded until the first time it is used. - anyone
  • For static class, though you can't override the static method, you can hide the static method from its parent. - anyone
  • if Animal animal = new Cat(); then animal.foo(); what happens? - anyone
  • @jmoreno static class is not loaded until the first time use? I believe it is stored in the stack memory on compile time. And it is instantly accessed.. isnt it? - anyone
  • @Luminous_Dev: at least for .net, a static class has a constructor that runs when first accessed, so no it is not instantly accessible. The static constructor could in theory take an unbounded amount of time. Where it (or any other class is stored) is an implementation detail, that is not really relevant to this question. - anyone

Another advantage of a singleton is that it can easily be serialized, which may be necessary if you need to save its state to disc, or send it somewhere remotely.

Answered   2023-09-20 20:59:34

I'm not a great OO theorist, but from what I know, I think the only OO feature that static classes lack compared to Singletons is polymorphism. But if you don't need it, with a static class you can of course have inheritance ( not sure about interface implementation ) and data and function encapsulation.

The comment of Morendil, "The design style embodied in a static class is purely procedural" I may be wrong, but I disagree. In static methods you can access static members, which would be exactly the same as singleton methods accessing their single instance members.

edit:
I'm actually thinking now that another difference is that a Static class is instantiated at program start* and lives throughout the whole life span of the program, while a singleton is explicitly instantiated at some point and can be destroyed also.

* or it may be instantiated at first use, depending on the language, I think.

Answered   2023-09-20 20:59:34

  • Yes, everyone else seems to ignore the fact that a class with static methods can also have private static fields which it can still use to maintain state (and expose some of them to the client code via public static setters/getters). - anyone

To illustrate Jon's point what's shown below cannot be done if Logger was a static class.The class SomeClass expects an instance of ILogger implementation to be passed into its constructor.

Singleton class is important for dependency injection to be possible.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {

            var someClass = new SomeClass(Logger.GetLogger());
        }


    }

    public class SomeClass 
    {
        public SomeClass(ILogger MyLogger)
        {

        }
    }

    public class Logger : ILogger
    {
        private static Logger _logger;
        private Logger() { }

        public static Logger GetLogger()
        {
            if (_logger==null)
            {
                _logger = new Logger();
            }

            return _logger;
        }

        public void Log()
        {

        }

    }


    public interface ILogger
    {
         void Log();
    }
}

Answered   2023-09-20 20:59:34

Singleton's are instantiated. It's just that there's only one instance ever created, hence the single in Singleton.

A static class on the other hand can't be instantiated.

Answered   2023-09-20 20:59:34

Well a singleton is just a normal class that IS instantiated but just once and indirectly from the client code. Static class is not instantiated. As far as I know static methods (static class must have static methods) are faster than non-static.

Edit:
FxCop Performance rule description: "Methods which do not access instance data or call instance methods can be marked as static (Shared in VB). After doing so, the compiler will emit non-virtual call sites to these members which will prevent a check at runtime for each call that insures the current object pointer is non-null. This can result in a measurable performance gain for performance-sensitive code. In some cases, the failure to access the current object instance represents a correctness issue."
I don't actually know if this applies also to static methods in static classes.

Answered   2023-09-20 20:59:34

Main differences are:

  • Singleton has an instance/object while static class is a bunch of static methods
  • Singleton can be extended e.g. through an interface while static class can't be.
  • Singleton can be inherited which supports open/close principles in SOLID principles on the other hand static class can't be inherited and we need to make changes in itself.
  • Singleton object can be passed to methods while static class as it does not have instance can't be passed as parameters

Answered   2023-09-20 20:59:34

Distinction from static class

JDK has examples of both singleton and static, on the one hand java.lang.Math is a final class with static methods, on the other hand java.lang.Runtime is a singleton class.

Advantages of singleton

  • If your need to maintain state than singleton pattern is better choice than static class, because maintaining state in static class leads to bugs, especially in concurrent environment, that could lead to race conditions without adequate synchronization parallel modification by multiple threads.

  • Singleton class can be lazy loaded if its a heavy object, but static class doesn't have such advantages and always eagerly loaded.

  • With singleton, you can use inheritance and polymorphism to extend a base class, implement an interface and provide different implementations.

  • Since static methods in Java cannot be overridden, they lead to inflexibility. On the other hand, you can override methods defined in singleton class by extending it.

Disadvantages of static class

  • It is easier to write unit test for singleton than static class, because you can pass mock object whenever singleton is expected.

Advantages of static class

  • Static class provides better performance than singleton, because static methods are bonded on compile time.

There are several realization of singleton pattern each one with advantages and disadvantages.

  • Eager loading singleton
  • Double-checked locking singleton
  • Initialization-on-demand holder idiom
  • The enum based singleton

Detailed description each of them is too verbose so I just put a link to a good article - All you want to know about Singleton

Answered   2023-09-20 20:59:34

Singleton is better approach from testing perspective. Unlike static classes , singleton could implement interfaces and you can use mock instance and inject them.

In the example below I will illustrate this. Suppose you have a method isGoodPrice() which uses a method getPrice() and you implement getPrice() as a method in a singleton.

singleton that’s provide getPrice functionality:

public class SupportedVersionSingelton {

    private static ICalculator instance = null;

    private SupportedVersionSingelton(){

    }

    public static ICalculator getInstance(){
        if(instance == null){
            instance = new SupportedVersionSingelton();
        }

        return instance;
    }

    @Override
    public int getPrice() {
        // calculate price logic here
        return 0;
    }
}

Use of getPrice:

public class Advisor {

    public boolean isGoodDeal(){

        boolean isGoodDeal = false;
        ICalculator supportedVersion = SupportedVersionSingelton.getInstance();
        int price = supportedVersion.getPrice();

        // logic to determine if price is a good deal.
        if(price < 5){
            isGoodDeal = true;
        }

        return isGoodDeal;
    }
}


In case you would like to test the method isGoodPrice , with mocking the getPrice() method you could do it by:
Make your singleton implement an interface and inject it. 



  public interface ICalculator {
        int getPrice();
    }

Final Singleton implementation:

public class SupportedVersionSingelton implements ICalculator {

    private static ICalculator instance = null;

    private SupportedVersionSingelton(){

    }

    public static ICalculator getInstance(){
        if(instance == null){
            instance = new SupportedVersionSingelton();
        }

        return instance;
    }

    @Override
    public int getPrice() {
        return 0;
    }

    // for testing purpose
    public static void setInstance(ICalculator mockObject){
        if(instance != null ){
instance = mockObject;
    }

test class:

public class TestCalculation {

    class SupportedVersionDouble implements ICalculator{
        @Override
        public int getPrice() { 
            return 1;
        }   
    }
    @Before
    public void setUp() throws Exception {
        ICalculator supportedVersionDouble = new SupportedVersionDouble();
        SupportedVersionSingelton.setInstance(supportedVersionDouble);

    }

    @Test
    public void test() {
          Advisor advidor = new Advisor();
          boolean isGoodDeal = advidor.isGoodDeal();
          Assert.assertEquals(isGoodDeal, true);

    }

}

In case we take the alternative of using static method for implementing getPrice() , it was difficult to the mock getPrice(). You could mock static with power mock, yet not all product could use it.

Answered   2023-09-20 20:59:34

  • That's now not thread safe, and generally nasty in terms of how you access the interface implementation. Sure, having an interface is nice for testability - but then why bother with a singleton? Just avoid having a singleton at all; have one class implementing it for production purposes, one implementation for test purposes, and inject the right instance depending on what you're doing. No need to couple the singleton to its callers at all. - anyone
  • thanks for the feedback. it is very simple to make it thread safe. in addition ,i use singleton for caching purpose. - anyone
  • Yes, although with pointless overhead. Again, it's just simpler not to use a singleton. - anyone

I'm agree with this definition:

The word "single" means single object across the application life cycle, so the scope is at application level.

The static does not have any Object pointer, so the scope is at App Domain level.

Moreover both should be implemented to be thread-safe.

You can find interesting other differences about: Singleton Pattern Versus Static Class

Answered   2023-09-20 20:59:34

One notable difference is differed instantiation that comes with Singletons.

With static classes, it gets created by the CLR and we have not control on it. with singletons, the object gets instantiated on the first instance it's tried to be accessed.

Answered   2023-09-20 20:59:34

Below are some main differences between static class and singleton:

1.Singleton is a pattern, not a keyword like static. So for creating a static class static keyword is sufficient while in the case of singleton there is a need to write the logic for the singleton.

2.A singleton class must have a private default instance constructor, while a static class cannot contain any instance constructor.

3.A static class is neither instantiated nor extended, while a singleton class can be.

4.A static class is sealed implicitly, but the singleton class must be decorated as sealed explicitly.

5.It is possible for a singleton to implement the interface or inherit from another class, but the static class neither implements the interface nor extends from any other class.

6.We cannot implement the dependency injection with a static class, but DI is possible with the singleton class because it can be interface driven. The scope of the static class is at the app domain level because it is managed by the CLR, while the scope of the singleton object is across the application lifecycle.

7.A static class cannot have any destructor but a singleton class can define a destructor.

8.The singleton class instance can be passed as a parameter to another method while a static class cannot be because it contains only static members.

Answered   2023-09-20 20:59:34

  1. Lazy Loading
  2. Support of interfaces, so that separate implementation can be provided
  3. Ability to return derived type (as a combination of lazyloading and interface implementation)

Answered   2023-09-20 20:59:34

  • Nested static class can very much implement interface in java. Your second point is Wrong. - anyone

In many cases, these two have no practical difference, especially if the singleton instance never changes or changes very slowly e.g. holding configurations.

I'd say the biggest difference is a singleton is still a normal Java Bean as oppose to a specialized static-only Java class. And because of this, a singleton is accepted in many more situations; it is in fact the default Spring Framework's instantiation strategy. The consumer may or may not know it's a singleton being passed around, it just treat it like a normal Java bean. If requirement changes and a singleton needs to become a prototype instead, as we often see in Spring, it can be done totally seamlessly without a line of code change to the consumer.

Someone else has mentioned earlier that a static class should be purely procedural e.g. java.lang.Math. In my mind, such a class should never be passed around and they should never hold anything other than static final as attributes. For everything else, use a singleton since it's much more flexible and easier to maintain.

Answered   2023-09-20 20:59:34

We have our DB framework that makes connections to Back end.To Avoid Dirty reads across Multiple users we have used singleton pattern to ensure we have single instance available at any point of time.

In c# a static class cannot implement an interface. When a single instance class needs to implement an interface for a business contracts or IoC purposes, this is where I use the Singleton pattern without a static class

Singleton provides a way to maintain state in stateless scenarios

Hope that helps you..

Answered   2023-09-20 20:59:34

In an article I wrote I have described my point of view about why the singleton is much better than a static class:

  1. Static class is not actually canonical class – it’s a namespace with functions and variables
  2. Using static class is not a good practice because of breaking object-oriented programming principles
  3. Static class cannot be passed as a parameter for other
  4. Static class is not suitable for “lazy” initialization
  5. Initialization and using of static class is always hard tracked
  6. Implementing thread management is hard

Answered   2023-09-20 20:59:34

  • I would brush it up for english grammar, but otherwise, it is an interesting read :) - anyone
  • This is better answer as deals with the real use case specific problem rather than implementation details. - anyone
  • Singleton class provides an object(only one instance) during the application lifeCycle such as java.lang.Runtime

    While Static class only provide static methods such as java.lang.Math

  • Static methods in Java cannot be overridden, but methods defined in Singleton class can be overridden by extending it.

  • Singleton Class is capable of Inheritance and Polymorphism to extend a base class, implement an interface and capable of providing different implementations. whereas static not.

For eg: java.lang.Runtime,is a Singleton Class in Java, call to getRuntime() method returns the runtime object associated with the current Java application but ensures only one instance per JVM.

Answered   2023-09-20 20:59:34

a. Serialization - Static members belong to the class and hence can't be serialized.

b. Though we have made the constructor private, static member variables still will be carried to subclass.

c. We can't do lazy initialization as everything will be loaded upon class loading only.

Answered   2023-09-20 20:59:34

From a client perspective, static behavior is known to the client but Singleton behavior can be completed hidden from a client. Client may never know that there only one single instance he's playing around with again and again.

Answered   2023-09-20 20:59:34

I read the following and think it makes sense too:

Taking Care of Business

Remember, one of the most important OO rules is that an object is responsible for itself. This means that issues regarding the life cycle of a class should be handled in the class, not delegated to language constructs like static, and so on.

from the book Objected-Oriented Thought Process 4th Ed.

Answered   2023-09-20 20:59:34

  • I would disagree, as this really just adds a responsibility to the class, which (assuming it does anything) means it now violates the Single Responsibility Principle. - anyone
  1. We can create the object of singleton class and pass it to method.

  2. Singleton class doesn't any restriction of inheritance.

  3. We can't dispose the objects of a static class but can singleton class.

Answered   2023-09-20 20:59:34

  • What is the use of passing a singleton into a method if there's always only one and that one always has a static reference? - anyone