CareerCup

Serialize/Deserialize the Object to a Database.

Each JVM downloads the object from DB->locks the DB Row till the instance is used->Writes back the object to DB->Unlocks the row from Database.

class Singleton
{
          private:
                Singleton();
                Singleton(const Singleton &copy);
                const Singleton& operator=(const Singleton &rhs);
          public:
                const Singleton& GetInstance()
                {
                      static Singleton _instance;
                      return _instance;
                 }
};

Use Enums
Item 3: Enforce the singleton property with a private constructor or an enum type

public enum Elvis {
	INSTANCE;
	public void leaveTheBuilding() { ... }
	}

Make it thread safe.

//Lazy instantiation using double locking mechanism.
class Singleton
{
private static Singleton instance;

private Singleton()
{
System.out.println("Singleton(): Initializing Instance");
}

public static Singleton getInstance()
{
if (instance == null)
{
synchronized(Singleton.class)
{
if (instance == null)
{
System.out.println("getInstance(): First time getInstance was invoked!");
instance = new Singleton();
}
}
}

return instance;
}

public void doSomething()
{
System.out.println("doSomething(): Singleton does something!");
}
}

in hadoop the counter is used like global accessibility. it's asynchronized during a task and get eventually synchronized after the task finished.

Guys there was this interesting article I read about making singleton class thread safe.

just before you create new instance, check if there is one already exist with do while loop.

options like JMS/DB or 3rd party tools like memcache . If WAS DistributedMap is built in and if Weblogic, Singleton Service. Terracotta and Oracle coherence are other ways. If Singleton is for cache, a simple timer with set refresh intervals works just as fine.

This can be done through the readResolve method. When an object is read, replace it with the singleton instance. This ensures that nobody can create another instance by serializing and deserializing the singleton. For Example:

public final class MySingleton {
 private MySingleton() { }
 private static final MySingleton INSTANCE = new MySingleton();
 public static MySingleton getInstance() { return INSTANCE; }
 private Object readResolve() throws ObjectStreamException {
  // instead of the object we're on, 
  // return the class variable INSTANCE
  return INSTANCE; 
 }
}

This will ensure that only one instance is read when we are dealing with serialization/de-serialization.