Singleton

From Rosetta Code
Jump to: navigation, search
Task
Singleton
You are encouraged to solve this task according to the task description, using any language you may know.
A Global Singleton is a class of which only one instance exists within a program. Any attempt to use non-static members of the class involves performing operations on this one instance.

Contents

[edit] ActionScript

package
{
public class Singleton
{
 
private static var instance:Singleton;
 
// ActionScript does not allow private or protected constructors.
public function Singleton(enforcer:SingletonEnforcer) {
 
}
 
public static function getInstance():Singleton {
if (instance == null) instance = new Singleton(new SingletonEnforcer());
return instance;
}
}
}
 
internal class SingletonEnforcer {}

[edit] Ada

[edit] Non Thread Safe

package Global_Singleton is
procedure Set_Data (Value : Integer);
function Get_Data return Integer;
private
type Instance_Type is record
-- Define instance data elements
Data : Integer := 0;
end record;
Instance : Instance_Type;
end Global_Singleton;
package body Global_Singleton is
 
--------------
-- Set_Data --
--------------
 
procedure Set_Data (Value : Integer) is
begin
Instance.Data := Value;
end Set_Data;
 
--------------
-- Get_Data --
--------------
 
function Get_Data return Integer is
begin
return Instance.Data;
end Get_Data;
 
end Global_Singleton;

[edit] Thread Safe

package Protected_Singleton is
procedure Set_Data (Value : Integer);
function Get_Data return Integer;
private
protected Instance is
procedure Set(Value : Integer);
function Get return Integer;
private
Data : Integer := 0;
end Instance_Type;
end Protected_Singleton;
package body Protected_Singleton is
 
--------------
-- Set_Data --
--------------
 
procedure Set_Data (Value : Integer) is
begin
Instance.Set(Value);
end Set_Data;
 
--------------
-- Get_Data --
--------------
 
function Get_Data return Integer is
begin
return Instance.Get;
end Get_Data;
 
--------------
-- Instance --
--------------
 
protected body Instance is
 
---------
-- Set --
---------
 
procedure Set (Value : Integer) is
begin
Data := Value;
end Set;
 
---------
-- Get --
---------
 
function Get return Integer is
begin
return Data;
end Get;
 
end Instance;
 
end Protected_Singleton;

[edit] AutoHotkey

Works with: AutoHotkey_L

Translation of python borg pattern

b1 := borg()
b2 := borg()
msgbox % "b1 is b2? " . (b1 == b2)
b1.datum := 3
msgbox % "b1.datum := 3`n...`nb1 datum: " b1.datum "`nb2 datum: " b2.datum ; is 3 also
msgbox % "b1.datum is b2.datum ? " (b1.datum == b2.datum)
return
 
 
borg(){
static borg
If !borg
borg := Object("__Set", "Borg_Set"
, "__Get", "Borg_Get")
return object(1, borg, "base", borg)
}
 
 
Borg_Get(brg, name)
{
Return brg[1, name]
}
 
Borg_Set(brg, name, val)
{
brg[1, name] := val
Return val
}

[edit] C

Since C doesn't really support classes anyhow, there's not much to do. If you want somethin akin to a singleton, what you do is first declare the interface functions in a header (.h) file.

#ifndef SILLY_H
#define SILLY_H
 
extern void JumpOverTheDog( int numberOfTimes);
extern int PlayFetchWithDog( float weightOfStick);
 
#endif

Then in a separate C source (.c) file, define your structures, variables and functions.

...
#include "silly.h"
 
struct sDog {
float max_stick_weight;
int isTired;
int isAnnoyed;
};
 
static struct sDog lazyDog = { 4.0, 0,0 };
 
/* define functions used by the functions in header as static */
static int RunToStick( )
{...
}
/* define functions declared in the header file. */
 
void JumpOverTheDog(int numberOfTimes)
{ ...
lazyDog.isAnnoyed = TRUE;
}
int PlayFetchWithDog( float weightOfStick )
{ ...
if(weightOfStick < lazyDog.max_stick_weight){...
}

Code using the singleton includes the header and cannot create a struct sDog as the definition is only in the C source (or other header privately included by the silly.c source). Only the functions declared in the header may be used externally.

...
#include "silly.h"
...
/* code using the dog methods */
JumpOverTheDog( 4);
retrieved = PlayFetchWithDog( 3.1);
...

[edit] C++

[edit] Thread-safe

Operating System: Microsoft Windows NT/XP/Vista

Uses a Win32 flavor Mutex - a POSIX flavor Mutex could be used.
class Singleton
{
public:
static Singleton* Instance()
{
// We need to ensure that we don't accidentally create two Singletons
HANDLE hMutex = CreateMutex(NULL, FALSE, "MySingletonMutex");
WaitForSingleObject(hMutex, INFINITE);
 
// Create the instance of the class.
// Since it's a static variable, if the class has already been created,
// It won't be created again.
static Singleton myInstance;
 
// Release our mutex so that other application threads can use this function
ReleaseMutex( hMutex );
 
// Free the handle
CloseHandle( hMutex );
 
// Return a pointer to our mutex instance.
return &myInstance;
}
 
// Any other public methods
 
protected:
Singleton()
{
// Constructor code goes here.
}
~Singleton()
{
// Destructor code goes here.
}
 
// And any other protected methods.
}

[edit] Non-Thread-Safe

This version doesn't require Mutex, but it is not safe in a multi-threaded environment.

class Singleton
{
public:
static Singleton* Instance()
{
// Since it's a static variable, if the class has already been created,
// It won't be created again.
static Singleton myInstance;
 
// Return a pointer to our mutex instance.
return &myInstance;
}
 
// Any other public methods
 
protected:
Singleton()
{
// Constructor code goes here.
}
~Singleton()
{
// Destructor code goes here.
}
 
// And any other protected methods.
}

[edit] C#

A thread safe singleton implementation. To make it non-thread safe remove lockObject and the lock() statement.

// Usage: Singleton.Instance.SomeMethod()
class Singleton
{
private static Singleton _singleton;
private static object lockObject = new object();
private Singleton() {}
public static Singleton Instance
{
get
{
lock(lockObject)
{
if (_singleton == null)
_singleton = new Singleton();
}
return _singleton;
}
}
// The rest of the methods
}

[edit] Caché ObjectScript

In Caché, each job runs in a self-contained execution environment (i.e. a separate process instead of a thread). However, it is possible for each process to share data through multidimensional storage (global variables). This is because when the Caché virtual machine starts, it allocates a single, large chunk of shared memory to allow all Caché processes to access this data simultaneously. However, it is the responsibility of the application developer to ensure read and write access to objects is properly co-ordinated (or 'synchronized') between processes to prevent concurrency problems. Also, Caché defines any global variable whose name starts with 'CacheTemp' as being temporary, which means changes are not usually written to disk and are instead maintained within the in-memory buffer pool.

 
/// The <CLASS>Singleton</CLASS> class represents a global singleton object that can
/// be instantiated by multiple processes. The 'Get' class method is used to obtain
/// an in-memory object reference and the 'Set' method is used to save any changes to
/// state. See below for an example.
///
/// <EXAMPLE>
/// Set one=##class(Singleton).Get(,.sc)
/// Set one.GlobalProperty="Some Value"
/// Set sc=one.Set()
/// </EXAMPLE>
///
/// This class can also be extended.
Class User.Singleton Extends %SerialObject
{
 
Property GlobalProperty As %String;
 
/// Refer to <LINK href=/AboutConcurrency.html>About Concurrency</LINK> for more details
/// on the optional <var>pConcurrency</var> argument.
ClassMethod Get(pConcurrency As %Integer = -1, Output pStatus As %Status = {$$$OK}) As Singleton [ Final ]
{
// check if singleton object already instantiated
Set oRef = ""
For {
Set oRef = $ZObjNext(oRef) If oRef = "" Quit
If oRef.%ClassName(1) = ..%ClassName(1) Quit
}
If $IsObject(oRef) Quit oRef
 
// determine what lock needs to be applied
If '$IsValidNum(pConcurrency, 0, -1, 4) {
Set pStatus = $$$ERROR($$$LockTypeInvalid, pConcurrency)
Quit $$$NULLOREF
}
If pConcurrency = -1 Set pConcurrency = $Xecute("Quit "_..#DEFAULTCONCURRENCY)
 
// acquire lock for global singleton object
Set lockTO = $ZUtil(115,4), lockOK = 1
If pConcurrency<4, pConcurrency {
Lock +^CacheTempUser("Singleton", ..%ClassName(1))#"S":lockTO Set lockOK = $Test
} ElseIf pConcurrency = 4 {
Lock +^CacheTempUser("Singleton", ..%ClassName(1)):lockTO Set lockOK = $Test
}
If 'lockOK {
If pConcurrency = 4 {
Set pStatus = $$$ERROR($$$LockFailedToAcquireExclusive, ..%ClassName(1))
} Else {
Set pStatus = $$$ERROR($$$LockFailedToAcquireRead, ..%ClassName(1))
}
Quit $$$NULLOREF
}
 
// retrieve global singleton object and deserialise
Set oId = $Get(^CacheTempUser("Singleton", ..%ClassName(1)))
Set oRef = ..%Open(oId) //,, .pStatus)
If '$IsObject(oRef) Set pStatus = $$$ERROR($$$GeneralError, "Failed to load singleton object.")
 
// release temporary lock
If (pConcurrency = 1) || (pConcurrency = 2) {
Lock -^CacheTempUser("Singleton", ..%ClassName(1))#"S"
}
 
// singleton object failed to load
If $$$ISERR(pStatus) {
// release retained lock
If pConcurrency = 3 {
Lock -^CacheTempUser("Singleton", ..%ClassName(1))#"S"
}
If pConcurrency = 4 {
Lock -^CacheTempUser("Singleton", ..%ClassName(1))
}
Quit $$$NULLOREF
}
 
// store concurrency state and return in-memory object reference
Set oRef.Concurrency = pConcurrency
Quit oRef
}
 
Method Set() As %Status [ Final ]
{
// check for version change
Set oId0 = $Get(^CacheTempUser("Singleton", ..%ClassName(1)))
Set oRef0 = ..%Open(oId0) //,, .sc)
If '$IsObject(oRef0) Quit $$$ERROR($$$GeneralError, "Failed to load singleton object.")
If oRef0.Version = ..Version {
Set ..Version = ..Version + 1
} Else {
Quit $$$ERROR($$$ConcurrencyVersionMismatch, ..%ClassName(1))
}
 
// serialise local singleton object and check status code
Set sc = ..%GetSwizzleObject(,.oId) If $$$ISERR(sc) Quit sc
 
// acquire exclusive lock on global singleton object
Set lockTO = $ZUtil(115,4)
Lock +^CacheTempUser("Singleton", ..%ClassName(1)):lockTO
If '$Test Quit $$$ERROR($$$LockFailedToAcquireExclusive, ..%ClassName(1))
 
// update global singleton object and release lock
Set ^CacheTempUser("Singleton", ..%ClassName(1)) = oId
Lock -^CacheTempUser("Singleton", ..%ClassName(1))
Quit $$$OK
}
 
Method %OnNew() As %Status [ Final, Internal ]
{
// do not allow constructor method to be called
Quit $$$ERROR($$$GeneralError, "Can't instantiate directly.")
}
 
Method %OnConstructClone() As %Status [ Final, Internal ]
{
// do not allow singleton object to be cloned
Quit $$$ERROR($$$GeneralError, "Can't clone instance.")
}
 
Method %OnClose() As %Status [ Final, Internal ]
{
// reference count for singleton object is now zero, so
// release lock on global singleton object, if applicable
If ..Concurrency = 3 Lock -^CacheTempUser("Singleton", ..%ClassName(1))#"S"
If ..Concurrency = 4 Lock -^CacheTempUser("Singleton", ..%ClassName(1))
Quit $$$OK
}
 
Property Concurrency As %Integer [ Final, Private, Transient ];
 
Property Version As %Integer [ Final, Private ];
 
}
 
Examples:
USER>Set one=##class(Singleton).Get()
USER>Set one.GlobalProperty="Some Value"
USER>Set sc=one.Set()

[edit] Common Lisp

Since Common Lisp uses generic functions for dispatch, creating a class is not necessary. If the superclasses of the singleton are not important, the simplest thing to do is to use a particular symbol; methods use eql specializers to be applicable to only that object.

For a simple example, the following program constructs English sentences without worrying about extra space occurring at points where no text (the-empty-phrase, our singleton) is inserted.

(defgeneric concat (a b)
(:documentation "Concatenate two phrases."))
 
(defclass nonempty-phrase ()
((text :initarg :text :reader text)))
 
(defmethod concat ((a nonempty-phrase) (b nonempty-phrase))
(make-instance 'nonempty-phrase :text (concatenate 'string (text a) " " (text b))))
 
(defmethod concat ((a (eql 'the-empty-phrase)) b)
b)
 
(defmethod concat (a (b (eql 'the-empty-phrase)))
a)
 
(defun example ()
(let ((before (make-instance 'nonempty-phrase :text "Jack"))
(mid (make-instance 'nonempty-phrase :text "went"))
(after (make-instance 'nonempty-phrase :text "to fetch a pail of water")))
(dolist (p (list 'the-empty-phrase
(make-instance 'nonempty-phrase :text "and Jill")))
(dolist (q (list 'the-empty-phrase
(make-instance 'nonempty-phrase :text "up the hill")))
(write-line (text (reduce #'concat (list before p mid q after))))))))

Thread safety is irrelevant since the singleton is created at load time, not first access.

[edit] D

module singleton ;
import std.stdio ;
import std.thread ;
import std.random ;
import std.c.time ;
 
class Dealer {
private static Dealer me ;
static Dealer Instance() {
writefln(" Calling Dealer... ") ;
if(me is null) // Double Checked Lock
synchronized // this part of code can only be executed by one thread a time
if(me is null)
me = new Dealer ;
return me ;
}
private static string[] str = ["(1)Enjoy", "(2)Rosetta", "(3)Code"] ;
private int state ;
private this() {
for(int i = 0 ; i < 3 ; i++) {
writefln("...calling Dealer... ") ;
msleep(rand() & 2047) ;
}
writefln(">>Dealer is called to come in!") ;
state = str.length - 1 ;
}
Dealer nextState() {
synchronized(this) // accessed to Object _this_ is locked ... is it necessary ???
state = (state + 1) % str.length ;
return this ;
}
string toString() { return str[state] ; }
}
 
class Coder : Thread {
private string name_ ;
Coder hasName(string name) { name_ = name ; return this ; }
override int run() {
msleep(rand() & 1023) ;
writefln(">>%s come in.", name_) ;
Dealer single = Dealer.Instance ;
msleep(rand() & 1023) ;
for(int i = 0 ; i < 3 ; i++) {
writefln("%9s got %-s", name_, single.nextState) ;
msleep(rand() & 1023) ;
}
return 0 ;
}
}
 
void main() {
Coder x = new Coder ;
Coder y = new Coder ;
Coder z = new Coder ;
 
x.hasName("Peter").start() ;
y.hasName("Paul").start() ;
z.hasName("Mary").start() ;
 
x.wait ; y.wait ; z.wait ;
}

Sample Output:

>>Mary come in.
   Calling Dealer...
...calling Dealer...
>>Peter come in.
   Calling Dealer...
>>Paul come in.
   Calling Dealer...
...calling Dealer...
...calling Dealer...
>>Dealer is called to come in!
     Mary got (1)Enjoy
    Peter got (2)Rosetta
     Mary got (3)Code
     Paul got (1)Enjoy
    Peter got (2)Rosetta
     Paul got (3)Code
     Paul got (1)Enjoy
     Mary got (2)Rosetta
    Peter got (3)Code

[edit] Delphi and Pascal

Detailed explanation here. (Delphi started out as an object-oriented version of Pascal.)

unit Singleton;
 
interface
 
type
TSingleton = class
private
//Private fields and methods here...
 
class var _instance: TSingleton;
protected
//Other protected methods here...
public
//Global point of access to the unique instance
class function Create: TSingleton;
 
destructor Destroy; override;
 
//Other public methods and properties here...
end;
 
implementation
 
{ TSingleton }
 
class function TSingleton.Create: TSingleton;
begin
if (_instance = nil) then
_instance:= inherited Create as Self;
 
result:= _instance;
end;
 
destructor TSingleton.Destroy;
begin
_instance:= nil;
inherited;
end;
 
end.

[edit] E

Since E uses closure-style objects rather than classes, a singleton is simply an object which is defined at the top level of the program, not inside any method. There are no thread-safety issues since the singleton, like every other object, belongs to some particular vat (but can be remotely invoked from other vats).

def aSingleton {
# ...
}

[edit] Erlang

Erlang is not object-oriented, so there is no such thing as a singleton class. The singleton is something of an anti-pattern in Erlang, so if you are tempted to do this, there is probably a better architecture. If you do want something akin to a singleton, you start and register a process that maintains its state in a message loop and provides its state to anyone that wants it or needs to change it. Since this is done with message passing, it's safe for concurrent use.

-module(singleton).
 
-export([get/0, set/1, start/0]).
 
-export([loop/1]).
 
% spec singleton:get() -> {ok, Value::any()} | not_set
get() ->
 ?MODULE ! {get, self()},
receive
{ok, not_set} -> not_set;
Answer -> Answer
end.
 
% spec singleton:set(Value::any()) -> ok
set(Value) ->
 ?MODULE ! {set, self(), Value},
receive
ok -> ok
end.
 
start() ->
register(?MODULE, spawn(?MODULE, loop, [not_set])).
 
loop(Value) ->
receive
{get, From} ->
From ! {ok, Value},
loop(Value);
{set, From, NewValue} ->
From ! ok,
loop(NewValue)
end.

Here is an example of how to use it (from the shell). It assumes singleton:start/0 was already called from the supervisor tree (as would be typical if you were using something like this).

1> singleton:get().
not_set
2> singleton:set(apple).
ok
3> singleton:get().
{ok,apple}
4> singleton:set("Pear").
ok
5> singleton:get().
{ok,"Pear"}
6> singleton:set(42).
ok
7> singleton:get().
{ok,42}

[edit] Factor

USING: classes.singleton kernel io prettyprint ;
IN: singleton-demo
 
SINGLETON: bar
GENERIC: foo ( obj -- )
M: bar foo drop "Hello!" print ;
   ( scratchpad ) bar foo
   Hello!

[edit] Go

Works with: Go1

Go packages are singletons, in a way. Go does not use the word "class," and while Go structs might seem most like classes of other languages, Go packages are also like classes in that they represent an organization of declarations, including data and functions. All declarations in a package form a single package block. This block is delimited syntactically, has an associated identifier, and its members are accessed by this package identifier. This is much like classes in other languages.

Because packages cannot be imported multiple times, data declared at package level will only ever have a single instance, and the package as a whole serves as a singleton.

package singlep
 
// package level data declarations serve as singleton instance variables
var X, Y int
 
// package level functions serve as methods for a package-as-a-singleton
func F() int {
return Y - X
}

Example program using the package:

package main
 
import (
"fmt"
"singlep"
)
 
func main() {
// dot selector syntax references package variables and functions
singlep.X = 2
singlep.Y = 3
fmt.Println(singlep.X, singlep.Y)
fmt.Println(singlep.F())
}
Output:
2 3
1

[edit] Groovy

@Singleton
class SingletonClass {
 
def invokeMe() {
println 'invoking method of a singleton class'
}
 
static void main(def args) {
SingletonClass.instance.invokeMe()
}
}

Output:

invoking method of a singleton class

[edit] Icon and Unicon

Icon is not object oriented, but Unicon supports O-O programming.

class Singleton
method print()
write("Hi there.")
end
initially
write("In constructor!")
Singleton := create |self
end
 
procedure main()
Singleton().print()
Singleton().print()
end

This Unicon example uses a number of Icon features.

  • The class descriptor Singleton is a first-class global object.
  • The create keyword yields a co-routine which can be activated like a function call.
  • The monadic operator | repeatedly yields the iteration of it's argument - in this case, it yields the object created (self).
  • The initializer of each object actually replaces the global object Singleton with a coroutine that returns ... the first object created. Therefore there is no further access to the true Singleton constructor; future attempts to create the object instead just activates the co-routine.

NOTE: this could be subverted by capturing a reference to Singleton prior to the first object construction.

[edit] Io

Io does not have globals. But it is easy to make singleton objects:

Singleton := Object clone
Singleton clone = Singleton

[edit] J

In J, all classes are singletons though their objects are not. (Class names may be used in any context where object references may be used, and object references can be used in almost every context where a class name may be used.)

Singletons should not have a constructor so any attempt to construct an instance of a singleton (dyadic conew) would fail. Other than that, singletons are defined like any other class in J.

[edit] Java

[edit] Thread-safe

wp:Double-checked locking; only use with Java 1.5+

class Singleton
{
private static Singleton myInstance;
public static Singleton getInstance()
{
if (myInstance == null)
{
synchronized(Singleton.class)
{
if (myInstance == null)
{
myInstance = new Singleton();
}
}
}
 
return myInstance;
}
 
protected Singleton()
{
// Constructor code goes here.
}
 
// Any other methods
}

[edit] Thread-Safe Lazy-Loaded

This is the wp:Initialization-on-demand holder idiom.

public class Singleton {
private Singleton() {
// Constructor code goes here.
}
 
private static class LazyHolder {
private static final Singleton INSTANCE = new Singleton();
}
 
public static Singleton getInstance() {
return LazyHolder.INSTANCE;
}
}

[edit] Non-Thread-Safe

class Singleton
{
private static Singleton myInstance;
public static Singleton getInstance()
{
if (myInstance == null)
{
myInstance = new Singleton();
}
 
return myInstance;
}
 
protected Singleton()
{
// Constructor code goes here.
}
 
// Any other methods
}

[edit] JavaScript

function Singleton() {
if(Singleton._instance) return Singleton._instance;
this.set("");
Singleton._instance = this;
}
 
Singleton.prototype.set = function(msg) { this.msg = msg; }
Singleton.prototype.append = function(msg) { this.msg += msg; }
Singleton.prototype.get = function() { return this.msg; }
 
 
var a = new Singleton();
var b = new Singleton();
var c = new Singleton();
 
a.set("Hello");
b.append(" World");
c.append("!!!");
 
document.write( (new Singleton()).get() );

[edit] Lasso

Lasso supports singletons on two levels.

[edit] Server wide singleton

// Define the thread if it doesn't exist 
// New definition supersede any current threads.
 
not ::serverwide_singleton->istype
? define serverwide_singleton => thread {
data public switch = 'x'
}
 
local(
a = serverwide_singleton,
b = serverwide_singleton,
)
 
#a->switch = 'a'
#b->switch = 'b'
 
#a->switch // b

[edit] Thread level singleton

// Define thread level singleton
 
define singleton => type {
data public switch = 'x'
public oncreate => var(.type)->isa(.type) ? var(.type) | var(.type) := self
}
 
local(
a = singleton,
b = singleton,
)
 
#a->switch = 'a'
#b->switch = 'b'
 
#a->switch // b

[edit] Logtalk

Logtalk supports both classes and prototypes. A prototype is a much simpler solution for defining a singleton object than defining a class with only an instance.

:- object(singleton).
 
:- public(value/1).
value(Value) :-
state(Value).
 
:- public(set_value/1).
set_value(Value) :-
retract(state(_)),
assertz(state(Value)).
 
:- private(state/1).
:- dynamic(state/1).
state(0).
 
:- end_object.

A simple usage example after compiling and loading the code above:

| ?- singleton::value(Value).
Value = 0
yes
 
| ?- singleton::(set_value(1), value(Value)).
Value = 1
yes

[edit] NetRexx

Uses a static field to avoid synchronization problems and the flawed "double-checked locking" idiom in JVMs. See www.ibm.com/developerworks/java/library/j-dcl/index.html for a detailed explanation.

/* NetRexx */
options replace format comments java crossref symbols binary
 
import java.util.random
 
class RCSingleton public
 
method main(args = String[]) public static
RCSingleton.Testcase.main(args)
return
 
-- ---------------------------------------------------------------------------
class RCSingleton.Instance public
 
properties private static
_instance = Instance()
 
properties private
_refCount = int
_random = Random
 
method Instance() private
this._refCount = 0
this._random = Random()
return
 
method getInstance public static returns RCSingleton.Instance
return _instance
 
method getRandom public returns Random
return _random
 
method addRef public protect
_refCount = _refCount + 1
return
 
method release public protect
if _refCount > 0 then
_refCount = _refCount - 1
return
 
method getRefCount public protect returns int
return _refCount
 
-- ---------------------------------------------------------------------------
class RCSingleton.Testcase public implements Runnable
 
properties private
_instance = RCSingleton.Instance
 
method run public
say threadInfo'|-'
thud = Thread.currentThread
_instance = RCSingleton.Instance.getInstance
thud.yield
_instance.addRef
say threadInfo'|'_instance.getRefCount
thud.yield
do
thud.sleep(_instance.getRandom.nextInt(1000))
catch ex = InterruptedException
ex.printStackTrace
end
_instance.release
say threadInfo'|'_instance.getRefCount
return
 
method main(args = String[]) public static
threads = [ Thread -
Thread(Testcase()), Thread(Testcase()), Thread(Testcase()), -
Thread(Testcase()), Thread(Testcase()), Thread(Testcase()) ]
say threadInfo'|-'
mn = Testcase()
mn._instance = RCSingleton.Instance.getInstance
say mn.threadInfo'|'mn._instance.getRefCount
mn._instance.addRef
say mn.threadInfo'|'mn._instance.getRefCount
do
loop tr over threads
(Thread tr).start
end tr
Thread.sleep(400)
catch ex = InterruptedException
ex.printStackTrace
end
mn._instance.release
say mn.threadInfo'|'mn._instance.getRefCount
return
 
method threadInfo public static returns String
trd = Thread.currentThread
tid = trd.getId
hc = trd.hashCode
info = Rexx(trd.getName).left(16, '_')':' -
|| Rexx(Long.toString(tid)).right(10, 0)':' -
|| '@'Rexx(Integer.toHexString(hc)).right(8, 0)
return info
 
 

output

main____________:0000000001:@035a8767|-
main____________:0000000001:@035a8767|0
main____________:0000000001:@035a8767|1
Thread-1________:0000000010:@22998b08|-
Thread-1________:0000000010:@22998b08|2
Thread-2________:0000000011:@7a6d084b|-
Thread-2________:0000000011:@7a6d084b|3
Thread-3________:0000000012:@2352544e|-
Thread-4________:0000000013:@457471e0|-
Thread-5________:0000000014:@7ecec0c5|-
Thread-6________:0000000015:@3dac2f9c|-
Thread-3________:0000000012:@2352544e|4
Thread-4________:0000000013:@457471e0|5
Thread-5________:0000000014:@7ecec0c5|6
Thread-6________:0000000015:@3dac2f9c|7
Thread-5________:0000000014:@7ecec0c5|6
main____________:0000000001:@035a8767|5
Thread-3________:0000000012:@2352544e|4
Thread-1________:0000000010:@22998b08|3
Thread-6________:0000000015:@3dac2f9c|2
Thread-2________:0000000011:@7a6d084b|1
Thread-4________:0000000013:@457471e0|0

[edit] Objeck

class Singleton {
@singleton : static : Singleton;
 
New : private () {
}
 
function : GetInstance() ~ Singleton {
if(@singleton <> Nil) {
@singleton := Singleton->New();
};
 
return @singleton;
}
 
method : public : DoStuff() ~ Nil {
...
}
}

[edit] Objective-C

[edit] Non-Thread-Safe

(Using Cocoa/OpenStep's NSObject as a base class)

// SomeSingleton.h
@interface SomeSingleton : NSObject
{
// any instance variables
}
 
+ (SomeSingleton *)sharedInstance;
 
@end
// SomeSingleton.m
@implementation SomeSingleton
 
+ (SomeSingleton *) sharedInstance
{
static SomeSingleton *sharedInstance = nil;
if (!sharedInstance) {
sharedInstance = [[SomeSingleton alloc] init];
}
return sharedInstance;
}
 
- (id)copyWithZone:(NSZone *)zone
{
return self;
}
 
- (id)retain
{
return self;
}
 
- (unsigned)retainCount
{
return UINT_MAX;
}
 
- (oneway void)release
{
// prevent release
}
 
- (id)autorelease
{
return self;
}
 
@end

[edit] Thread-Safe

Same as above except:

+ (SomeSingleton *) sharedInstance
{
static SomeSingleton *sharedInstance = nil;
@synchronized(self) {
if (!sharedInstance) {
sharedInstance = [[SomeSingleton alloc] init];
}
}
return sharedInstance;
}

[edit] With GCD

Same as above except:

+ (SomeSingleton *) sharedInstance
{
static SomeSingleton *sharedInstance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedInstance = [[SomeSingleton alloc] init];
});
return sharedInstance;
}

[edit] With class methods

It's possible to accomplish the same thing with class methods of some class, rather than instance methods on the instance of a singleton class. Data that needs to be kept as "instance variables" would instead be kept as static (file-local) global variables. "Initialization" of the singleton object would be done in the +initialize method, which is guaranteed to be called at most once for every class, the first time the class is messaged. This way, the singleton is also "lazy loaded" as needed.

In other words, here the class object serves as the singleton object. The "singleton class" is the metaclass of the class. The downside of this approach is that the "singleton class" (the metaclass of the class) cannot be made to explicitly inherit from a class of the user's choice, or implement a protocol of the user's choice. Also, there is no way to prevent subclasses of the class from being made, thus effectively creating "multiple instances" of the singleton class. Also, one cannot declare properties on the singleton (the class object).

[edit] ooRexx

 
a = .singleton~new
b = .singleton~new
 
a~foo = "Rick"
if a~foo \== b~foo then say "A and B are not the same object"
 
::class singleton
-- initialization method for the class
::method init class
expose singleton
-- mark this as unallocated. We could also just allocate
-- the singleton now, but better practice is probably wait
-- until it is requested
singleton = .nil
 
-- override the new method. Since this is a guarded
-- method by default, this is thread safe
::method new class
expose singleton
-- first request? Do the real creation now
if singleton == .nil then do
-- forward to the super class. We use this form of
-- FORWARD rather than explicit call ~new:super because
-- this takes care of any arguments passed to NEW as well.
forward class(super) continue
singleton = result
end
return singleton
 
-- an attribute that can be used to demonstrate this really is
a singleton.
::attribute foo
 

[edit] OxygenBasic

The singleton contains static members only. It may be instantiated any number of times, but the members will all be shared.

 
class singleton
static sys a,b,c
static string s,t,u
static double x,y,z
end class
 
'TEST
'====
 
singleton A
singleton B
A.c=3
print B.c 'result 3
print sizeof B 'result 0
 

[edit] Oz

Singleton is not a common pattern in Oz programs. It can be implemented by limiting the scope of the class definition such that only the GetInstance function has access to it.

declare
local
class Singleton
meth init
skip
end
end
L = {NewLock}
Instance
in
fun {GetInstance}
lock L then
if {IsFree Instance} then
Instance = {New Singleton init}
end
Instance
end
end
end

This will work as long as all functors are linked with import statements. If you use multiple calls to Module.link instead, you will get multiple instances of the "Singleton".

[edit] Perl

package Singleton;
use strict;
use warnings;
 
my $Instance;
 
sub new {
my $class = shift;
$Instance ||= bless {}, $class; # initialised once only
}
 
sub name {
my $self = shift;
$self->{name};
}
 
sub set_name {
my ($self, $name) = @_;
$self->{name} = $name;
}
 
package main;
 
my $s1 = Singleton->new;
$s1->set_name('Bob');
printf "name: %s, ref: %s\n", $s1->name, $s1;
 
my $s2 = Singleton->new;
printf "name: %s, ref: %s\n", $s2->name, $s2;

[edit] Perl 6

class Singleton {
# We create a lexical variable in the class block that holds our single instance.
my Singleton $instance = Singleton.bless; # You can add initialization arguments here.
method new {!!!} # Singleton.new dies.
method instance { $instance; }
}

[edit] PHP

class Singleton {
protected static $instance = null;
public $test_var;
private function __construct(){
//Any constructor code
}
public static function getInstance(){
if (is_null(self::$instance)){
self::$instance = new self();
}
return self::$instance;
}
}
 
$foo = Singleton::getInstance();
$foo->test_var = 'One';
 
$bar = Singleton::getInstance();
echo $bar->test_var; //Prints 'One'
 
$fail = new Singleton(); //Fatal error

[edit] PicoLisp

As there is no physical difference between classes and objects, we can use the class symbol itself.

(class +Singleton)
 
(dm message1> ()
(prinl "This is method 1 on " This) )
 
(dm message2> ()
(prinl "This is method 2 on " This) )

Output:

: (message1> '+Singleton)
This is method 1 on +Singleton
-> +Singleton

: (message2> '+Singleton)
This is method 2 on +Singleton
-> +Singleton

[edit] Python

In Python we use the Borg pattern to share state between instances rather than concentrate on identity.

Every instance of the Borg class will share the same state:

>>> class Borg(object):
__state = {}
def __init__(self):
self.__dict__ = self.__state
# Any other class names/methods
 
 
>>> b1 = Borg()
>>> b2 = Borg()
>>> b1 is b2
False
>>> b1.datum = range(5)
>>> b1.datum
[0, 1, 2, 3, 4]
>>> b2.datum
[0, 1, 2, 3, 4]
>>> b1.datum is b2.datum
True
>>> # For any datum!

[edit] PureBasic

[edit] Native version

Thread safe version.

Global SingletonSemaphore=CreateSemaphore(1)
 
Interface OO_Interface ; Interface for any value of this type
Get.i()
Set(Value.i)
Destroy()
EndInterface
 
Structure OO_Structure ; The *VTable structure
Get.i
Set.i
Destroy.i
EndStructure
 
Structure OO_Var
*VirtualTable.OO_Structure
Value.i
EndStructure
 
Procedure OO_Get(*Self.OO_Var)
ProcedureReturn *Self\Value
EndProcedure
 
Procedure OO_Set(*Self.OO_Var, n)
*Self\Value = n
EndProcedure
 
Procedure CreateSingleton()
If TrySemaphore(SingletonSemaphore)
*p.OO_Var = AllocateMemory(SizeOf(OO_Var))
If *p
*p\VirtualTable = ?VTable
EndIf
EndIf
ProcedureReturn *p
EndProcedure
 
Procedure OO_Destroy(*Self.OO_Var)
FreeMemory(*Self)
SignalSemaphore(SingletonSemaphore)
EndProcedure
 
DataSection
VTable:
Data.i @OO_Get()
Data.i @OO_Set()
Data.i @OO_Destroy()
EndDataSection

[edit] Simple OOP extension

Using the open-source precompiler SimpleOOP.

Singleton Class Demo
BeginPrivate
Name$
X.i
EndPrivate
 
Public Method Init(Name$)
This\Name$ = Name$
EndMethod
 
Public Method GetX()
MethodReturn This\X
EndMethod
 
Public Method SetX(n)
This\X = n
EndMethod
 
Public Method Hello()
MessageRequester("Hello!", "I'm "+This\Name$)
EndMethod
 
EndClass

[edit] Racket

Singletons are not very useful in Racket, because functions that use module state are more straightforward. However, classes are first class values, and therefore they follow the same rules as all other bindings. For example, a class can be made and instantiated but not provided to client files:

 
#lang racket
(provide instance)
(define singleton%
(class object%
(super-new)))
(define instance (new singleton%))
 

Or better, not name the class at all:

 
#lang racket
(provide instance)
(define instance
(new (class object%
(define/public (foo) 123)
(super-new))))
 

[edit] Ruby

require 'singleton'
class MySingleton
include Singleton
# constructor and/or methods go here
end
 
a = MySingleton.instance # instance is only created the first time it is requested
b = MySingleton.instance
puts a.equal?(b) # outputs "true"

[edit] Scala

The object construct in Scala is a singleton.

object Singleton {
// any code here gets executed as if in a constructor
}

[edit] Slate

Clones of Oddball themselves may not be cloned. Methods and slots may still be defined on them:

define: #Singleton &builder: [Oddball clone]

[edit] Tcl

Works with: Tcl version 8.6
or
Library: TclOO

ref http://wiki.tcl.tk/21595

package require TclOO
 
# This is a metaclass, a class that defines the behavior of other classes
oo::class create singleton {
superclass oo::class
variable object
unexport create ;# Doesn't make sense to have named singletons
method new args {
if {![info exists object]} {
set object [next {*}$args]
}
return $object
}
}
 
singleton create example {
method counter {} {
my variable count
return [incr count]
}
}

Demonstrating in an interactive shell

% set a [example new]
::oo::Obj20
% set b [example new] ;# note how this returns the same object name
::oo::Obj20
% expr {$a == $b}
1
% $a counter
1
% $b counter
2
% $a counter
3
% $b counter
4

[edit] Vala

public class Singleton : Object {
static Singleton? instance;
 
// Private constructor
Singleton() {
 
}
 
// Public constructor
public static Singleton get_instance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
 
void main() {
Singleton a = Singleton.get_instance();
Singleton b = Singleton.get_instance();
if (a == b) {
print("Equal.\n");
}
}

[edit] zkl

A class declared static only has one instance, ever. However, a class with the same name & structure could be created in another scope.

class [static] Borg{ var v }
b1 := Borg; b2 := Borg();
b1 == b2 //--> True
b1.v=123; b2.v.println(); //--> 123
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox