Is this implementation correct for singleton?

Related searches

Closed. This question needs to be more focused. It is not currently accepting answers.

Your implementation is fine and is thread safe. The singleton instantiation performed in a static field this is :

private final static Singleton ss = new Singleton();

prevents any race condition as it is executed before that the object be accessible and the remaining of the code guarantees also that only one instance of the class is created, particularly because this statement is the single time where the constructor is invoked and the constructor is private too.

Note that this is an eager instantiation. You could also use a lazy way with a static holder class but it is really noise because the overhead is almost null.

Singleton Design Pattern, Classical Java implementation of singleton multiple threads offer the obj variable correctly when it is being initialized to Singleton instance. Note that Singleton obj is not created until we need it and call getInstance() method. This is called lazy instantiation. The main problem with above method is that it is not thread safe. Consider the following execution sequence. This execution sequence creates two objects for singleton. Therefore this classic implementation is not thread safe.

The way I implement a singleton is like so:

public class Singleton {
  private static Singleton _instance;

  private Singleton() {
  }

  public static Singleton getInstance() {
      if (_instance == null) {
         _instance = new Singleton();
      }
      return _instance;
  }

Implementing the Singleton Pattern in C#, If the above Singleton is correctly implemented than below code should return the same hash key. Below is the output log with the hash code of both the instances. Singleton pattern is a design solution where an application wants to have one and only one instance of any class, in all possible scenarios without any exceptional condition. It has been debated long enough in java community regarding possible approaches to make any class singleton. Still, you will find people not satisfied with any solution you give. They can not be overruled either. In this

public class Singleton {

private Singleton () {
}

 public static Singleton() {
    return new Singleton();
 }

}

How to make the perfect Singleton? | by Keval Patel, With Singletons implemented as single instances instead of static class In the correct solution, seen in Listing 5, make getInstance() a synchronized method:. Use of the Singleton pattern can be a bit ambiguous about whether we want lazy instantiation, enforced uniqueness, or global access so be sure to think carefully about why you're reaching for the singleton, and choose an implementation that gets those features right, rather than using a standard for all three when you only need one.

Java Singleton Design Pattern Example Best Practices, I'm currently trying to implement the singleton pattern in C++. After reading about it for a while now, it seems like there are a really large amount of different ways to do this. Is the way I ended up doing it correct or did I miss out on something important here?

When is a Singleton not a Singleton?, It is pretty easy to implement the Singleton Pattern in any object oriented programming languages like C++, JAVA or C#. There are lots of different ways to implement the Singleton Pattern. But by using a private constructor and a static method to create and return an instance of the class is a popular way for implementing Singleton Pattern.

Name Singleton; Type Creational Pattern; Many times we need to restrict a class to only a single instance.Singleton pattern restricts the clients of the class from creating multiple instances of the class.There is a global access point ,such as a method,which returns the same object every time it is invoked.Singleton pattern is a creational pattern since it specifies how to create an object of

Comments

Use Enum for Singleton.
This implementation is not fully correct.
IMHO this question is too broad. Too many factors could be evaluated in order to provide a "correct" answer and generate a lot of different opinions: thread safety, performance, code readability, etc. If you define the scope of correctness.... that would be helpful.
This is not thread-safe. Enums are the simplest way to get thread-safe and correct singleton in Java.
True. But I was working under the assumption OP wasn't using multithreading since it wasn't mentioned. Can modify the answer as needed if that's the case.
Returning a different instance each time is the exact opposite of a singleton.
constructor cant not be static method