Browse DevX
Sign up for e-mail newsletters from DevX

Tip of the Day
Language: Java
Expertise: Advanced
Dec 15, 1998



Building the Right Environment to Support AI, Machine Learning and Deep Learning

A Mutable Singleton

The Singleton pattern ensures that only one instance of an object is instantiated at run time and that this instance is accessible from a well-known access point. You can change the "singular" property of a class at run time. For example, the instantiated object is a Singleton when the application is started, but you can convert it to a non-Singleton at run time.

Consider an application that can run either on a single server only in one mode and on a client and a server in another mode. You can set this mode at run time. In the server mode, you only want one instance of the application running. An example of this would be a logger that logs the server at run time. However, at some stage, you may want it to start logging client activity without shutting the application down. In this case, you want the logger to morph to a non-Singleton at run time when desired.

The following code shows an implementation of The MutableSingleton:

1.    private class MutableSingleton {
3.      boolean singletonMode_ = true;
4.      private static MutableSingleton self_ = null;
6.      private MutableSingleton () {
7.       // Construct the object
8.      }
10.   public static MutableSingleton instance () {
11.	  // if we're NOT in the "singleton" mode, 
12. 	  // just create a new instance every time
13.	  // this method is called
14.     if (! isSingleton() ) {
15.       return new MutableSingleton();
16.     }
18.	  // if we ARE in the "singleton" mode,
19.	  // check to see whether our single instance has
20.	  // already been created.
21.     if (self_ == null) {
22.       self_ = new MutableSingleton();
23.     }
24.     return self_;
25.   }
27.	/**
28.	 * Allows to set the mode in which this class operates -
29.	 * singleton or not-singleton.
30.	 * If <code>true</code> is passed in, the class behaves
31.	 * like singleton, i.e. every time the <code>instance()</code>
32.	 * method is called, the same instance is returned.
33.	 * If <code>false</code> is passed in, the class behaves
34.	 * just like regular class with factory method, i.e.
35.	 * every time the <code>instance()</code> method is called,
36.	 * new instance is created and returned.
37.	 * The default mode is singleton.
38.	 */
39.   public void setSingleton (boolean singletonMode) {
40.     singletonMode_ = singletonMode;
41.   }
43.	public boolean isSingleton() {
44.	  return singletonMode_;
45.	}
47. }

This class enhances a standard Singleton implementation by providing and using a boolean variable called isSingleton that indicates whether the class is a Singleton. The variable is declared on line 3 and is initialized to false. It is used on lines 11-12 to always create a new object if it is not set (i.e., the class is not in Singleton mode). Lines 21-24 provide the setter method for this variable.

This class may be used as follows:

1.     // Get a MutableSingleton object.
2.     MutableSingleton aSingleton = MutableSingleton.instance();
4.     // Get another reference to the SAME MutableSingleton object
5.     MutableSingleton anotherSingleton = MutableSingleton.instance();
7.     // Reset the Singleton property
8.     MutableSingleton.setSingleton(false);
10.  // Now get a new object
11.  MutableSingleton notASingleton = MutableSingleton.instance();
Note that the first two instantiations on lines 4-8 give references (aSingleton and anotherSingleton) to the same object, whereas the instantiation on line 11 gives a reference (notASingleton) to a new instance of the Singleton class. This is because on line 8, the Singleton property of the class is set to false. This causes lines 11-12 to be executed in the earlier code excerpt and a new MutableSingleton object is created.
Ajit Sagar
Comment and Contribute






(Maximum characters: 1200). You have 1200 characters left.



Thanks for your registration, follow us on our social networks to keep up-to-date