objectMySingleton{
println("Creating the singleton")
vali:Int=0
}

Traditional simple way using synchronization

publicclass Singleton{
privatevolatilestaticSingletonsingleton;// volatile is needed so that multiple thread can reconcile the instance
privateSingleton(){}
publicstaticSingletongetSingleton(){// synchronized keyword has been removed from here
if(singleton==null){// needed because once there is singleton available no need to aquire monitor again & again as it is costly
synchronized(Singleton.class){
if(singleton==null){// this is needed if two threads are waiting at the monitor at the time when singleton was getting instantiated
singleton=newSingleton();
}
}
}
returnsingleton;
}
}

Initialization on Demand Holder Idiom

publicclass Singleton{
// Private constructor prevents instantiation from other classes
privateSingleton(){}

/**
 * SingletonHolder is loaded on the first execution of Singleton.getInstance()
 * or the first access to SingletonHolder.INSTANCE, not before.
 */
privatestaticclass SingletonHolder{
privatestaticfinalSingletonINSTANCE=newSingleton();
}

publicstaticSingletongetInstance(){
returnSingletonHolder.INSTANCE;
}
}

The Enum-way

publicenumSingleton{
INSTANCE;
}

importstd.stdio;
importstd.string;
classSingleton(T){
privatestaticTinstance;
publicstaticTopCall(){
if(instanceisnull){
instance=newT;
}
returninstance;
}
}
classFoo{
publicthis(){
writefln("Foo Constructor");
}
}
voidmain(){
Fooa=Singleton!(Foo)();
Foob=Singleton!(Foo)();
}

// this class should be in a package to make private this() not visible
classSingleton{
privatestaticSingletoninstance;

publicstaticSingletonopCall(){
if(instanceisnull){
instance=newSingleton();
}
returninstance;
}
privatethis(){
writefln("Singleton constructor");
}
}
voidmain(){
Singletona=Singleton();
Singletonb=Singleton();
}

<?php
class Singleton {
 // object instance
 private static $instance;
 // The protected construct prevents instantiating the class externally. The construct can be
 // empty, or it can contain additional instructions...
 // This should also be final to prevent extending objects from overriding the constructor with
 // public.
 protected final function __construct() {
 ...
 }
 // The clone and wakeup methods prevents external instantiation of copies of the Singleton class,
 // thus eliminating the possibility of duplicate objects. The methods can be empty, or
 // can contain additional code (most probably generating error messages in response
 // to attempts to call).
 public function __clone() {
 trigger_error('Clone is not allowed.', E_USER_ERROR);
 }
 public function __wakeup() {
 trigger_error('Deserializing is not allowed.', E_USER_ERROR);
 }
 // This method must be static, and must return an instance of the object if the object
 // does not already exist.
 public static function getInstance() {
 if (!self::$instance instanceof self) {
 self::$instance = new self;
 }
 return self::$instance;
 }
 // One or more public methods that grant access to the Singleton object, and its private
 // methods and properties via accessor methods.
 public function doAction() {
 ...
 }
}
// usage
Singleton::getInstance()->doAction();
?>

package{
publicclassSingleton{
privatestaticvar_instance:Singleton=newSingleton();
publicfunctionSingleton(){
if(_instance){
thrownewError(
"Singleton can only be accessed through Singleton.getInstance()"
);
}
}
publicstaticfunctiongetInstance():Singleton{
return_instance;
}
}
}

@interface MySingleton : NSObject
{
}
+ (MySingleton*)sharedSingleton;
@end
@implementation MySingleton
+ (MySingleton*)sharedSingleton
{
staticMySingleton*sharedSingleton;

@synchronized(self)
{
if(!sharedSingleton)
sharedSingleton=[[MySingletonalloc]init];

returnsharedSingleton;
}
}
@end

+ (MySingleton*)sharedSingleton
{
staticMySingleton*sharedSingleton;
if(!sharedSingleton)
sharedSingleton=[[MySingletonalloc]init];
returnsharedSingleton;
}

@interface MySingleton : NSObject
{
}
+ (MySingleton*)sharedSingleton;
@end
@implementation MySingleton
staticMySingleton*sharedSingleton;
+ (MySingleton*)sharedSingleton
{
@synchronized(self)
{
if(!sharedSingleton)
[[MySingletonalloc]init];

returnsharedSingleton;
}
}
+(id)alloc
{
@synchronized(self)
{
NSAssert(sharedSingleton==nil,@"Attempted to allocate a second instance of a singleton.");
sharedSingleton=[superalloc];
returnsharedSingleton;
}
}
@end

publicclassSingleton
{
// The combination of static and readonly makes the instantiation
// thread safe. Plus the constructor being protected (it can be
// private as well), makes the class sure to not have any other
// way to instantiate this class than using this member variable.
publicstaticreadonlySingletonInstance=newSingleton();
// Protected constructor is sufficient to avoid other instantiation
// This must be present otherwise the compiler provides a default
// public constructor
//
protectedSingleton()
{
}
}

/// Class implements singleton pattern.
publicclassSingleton
{
//Use Lazy<T> to lazily initialize the class and provide thread-safe access
privatestaticreadonlyLazy<Singleton>_lazyInstance=newLazy<Singleton>(()=>newSingleton());

publicstaticSingletonInstance
{
get{return_lazyInstance.Value;}
}

privateSingleton(){}
}

/// Parent for singleton
/// <typeparam name="T">Singleton class</typeparam>
publicclassSingleton<T>whereT:class,new()
{
protectedSingleton(){}
privatesealedclassSingletonCreator<S>whereS:class,new()
{
privatestaticreadonlySinstance=newS();
//explicit static constructor to disable beforefieldinit 
staticSingletonCreator(){}
publicstaticSCreatorInstance
{
get{returninstance;}
}
}
publicstaticTInstance
{
get{returnSingletonCreator<T>.CreatorInstance;}
}
}
/// Concrete Singleton
publicclassTestClass:Singleton<TestClass>
{
publicstringTestProc()
{
return"Hello World";
}
}
// Somewhere in the code
.....
TestClass.Instance.TestProc();
.....

unitSingletn;
interface
uses
SysUtils,WinTypes,WinProcs,Messages,Classes,Graphics,Controls,
Forms,Dialogs;
type
TCSingleton=class(TComponent)
public
constructorCreate(AOwner:TComponent);override;
destructorDestroy;override;
end;
TOSingleton=class(TObject)
public
constructorCreate;
destructorDestroy;override;
end;
var
Global_CSingleton:TCSingleton;
Global_OSingleton:TOSingleton;
procedureRegister;
implementation
procedureRegister;
begin
RegisterComponents('Design Patterns',[TCSingleton]);
end;
{ TCSingleton }
constructorTCSingleton.Create(AOwner:TComponent);
begin
ifGlobal_CSingleton<>nilthen
{NB could show a message or raise a different exception here}
Abort
elsebegin
inheritedCreate(AOwner);
Global_CSingleton:=Self;
end;
end;
destructorTCSingleton.Destroy;
begin
ifGlobal_CSingleton=Selfthen
Global_CSingleton:=nil;
inheritedDestroy;
end;
{ TOSingleton }
constructorTOSingleton.Create;
begin
ifGlobal_OSingleton<>nilthen
{NB could show a message or raise a different exception here}
Abort
else
Global_OSingleton:=Self;
end;
destructorTOSingleton.Destroy;
begin
ifGlobal_OSingleton=Selfthen
Global_OSingleton:=nil;
inheritedDestroy;
end;
procedureFreeGlobalObjects;far;
begin
ifGlobal_CSingleton<>nilthen
Global_CSingleton.Free;
ifGlobal_OSingleton<>nilthen
Global_OSingleton.Free;
end;
begin
AddExitProc(FreeGlobalObjects);
end.

classBorg:
 __shared_state = {}
 def__init__(self):
 self.__dict__ = self.__shared_state
 # and whatever else is needed in the class -- that's all!

classSingleton (object):
 def__new__(cls, *args, **kwargs):
 if not hasattr(cls, 'self'):
 cls.self = object.__new__(cls)
 return cls.self
#Usage
mySingleton1 = Singleton()
mySingleton2 = Singleton()
 
#mySingleton1 and mySingleton2 are the same instance.
assert mySingleton1 is mySingleton2

classInheritableSingleton (object):
 instances = {}
 def__new__(cls, *args, **kwargs):
 if InheritableSingleton.instances.get(cls) is None:
 cls.__original_init__ = cls.__init__
 InheritableSingleton.instances[cls] = object.__new__(cls, *args, **kwargs)
 elif cls.__init__ == cls.__original_init__:
 defnothing(*args, **kwargs):
 pass
 cls.__init__ = nothing
 return InheritableSingleton.instances[cls]

classSingleton (NonSingletonClass, object):
 instance = None 
 def__new__(cls, *args, **kargs):
 if cls.instance is None:
 cls.instance = object.__new__(cls, *args, **kargs)
 return cls.instance

classSingletonType(type):
 def__call__(cls):
 if getattr(cls, '__instance__', None) is None:
 instance = cls.__new__(cls)
 instance.__init__()
 cls.__instance__ = instance
 return cls.__instance__
# Usage
classSingleton(object):
 __metaclass__ = SingletonType
 def__init__(self):
 print '__init__:', self
classOtherSingleton(object):
 __metaclass__ = SingletonType
 def__init__(self):
 print 'OtherSingleton __init__:', self
# Tests
s1 = Singleton()
s2 = Singleton()
assert s1
assert s2
assert s1 is s2
os1 = OtherSingleton()
os2 = OtherSingleton()
assert os1
assert os2
assert os1 is os2

packageMySingletonClass;
usestrict;
usewarnings;
use5.010;
subnew{
my($class)=@_;
state$the_instance;
if(!defined$the_instance){
$the_instance=bless{},$class;
}
return$the_instance;
}

packageMySingletonClass;
usestrict;
usewarnings;
my$THE_INSTANCE;
subnew{
my($class)=@_;
if(!defined$THE_INSTANCE){
$THE_INSTANCE=bless{},$class;
}
return$THE_INSTANCE;
}

require'singleton'
classExample
includeSingleton
end
# Access to the instance:
Example.instance