Singleton Design Pattern in JavaScript

A Singleton only allows for a single instantiation, but many instances of the same object. The Singleton restricts clients from creating multiple objects, after the first object created, it will return instances of itself.

Finding use cases for Singletons is difficult for most who have not yet used it prior. One example is using an office printer. If there are ten people in an office, and they all use one printer, ten computers share one printer (instance). By sharing one printer, they share the same resources.

var printer = (function () {      var printerInstance;      function create () {      function print() {         // underlying printer mechanics     }      function turnOn() {         // warm up         // check for paper     }      return {         // public + private states and behaviors         print: print,         turnOn: turnOn     };     }      return {     getInstance: function() {         if(!printerInstance) {         printerInstance = create();         }         return printerInstance;     }     };      function Singleton () {     if(!printerInstance) {         printerInstance = intialize();     }     };  })(); 

The create method is private because we do not want the client to access this, however, notice that the getInstance method is public. Each officer worker can generate a printer instance by interacting with the getInstance method, like so:

var officePrinter = printer.getInstance(); 

In AngularJS, Singletons are prevalent, the most notable being services, factories, and providers. Since they maintain state and provides resource accessing, creating two instances defeats the point of a shared service/factory/provider.

Race conditions occur in multi-threaded applications when more than one thread tries to access the same resource. Singletons are susceptible to race conditions, such that if no instance were initialized first, two threads could then create two objects instead of returning and instance. This defeats the purpose of a singleton. Therefore, developers must be privy to synchronization when implementing singletons in multithreaded applications.