Singleton: Difference between revisions

From Rosetta Code
Content added Content deleted
(added ruby)
No edit summary
Line 1: Line 1:
{{task|Basic language learning}}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.
{{task|Basic language learning}}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.

=={{header|ActionScript}}==
<actionscript>
package {
public class Singleton {
private static var instance:Singleton = new Singleton();
// ActionScript does not allow private or protected constructors.
public function Singleton() {
if (instance) {
throw new Error("Singleton instance can only be accessed through Singleton.getInstance()");
}
}

public static function getInstance():Singleton {
return instance;
}
}
}
</actionscript>


=={{header|Ada}}==
=={{header|Ada}}==

Revision as of 01:35, 7 January 2009

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.

ActionScript

<actionscript> package { 

   public class Singleton {
       private static var instance:Singleton = new Singleton();
       
       // ActionScript does not allow private or protected constructors.
       public function Singleton() {
           if (instance) {
               throw new Error("Singleton instance can only be accessed through Singleton.getInstance()");
           }
       }    

       public static function getInstance():Singleton {
           return instance;
       }
   }

} </actionscript>

Ada

Non Thread Safe

<ada>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;</ada>

<ada>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;</ada>

Thread Safe

<ada>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;</ada>

<ada>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;</ada>

C++

Thread-safe

Operating System: Microsoft Windows NT/XP/Vista 

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.
}

Non-Thread-Safe

This version doesn't require any operating-system or platform-specific features, 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.
}

D

<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 ;

}</d> 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

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 {
  # ...
}

Io

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

 Singleton := Object clone
 Singleton clone = Singleton

Objective-C

Non-Thread-Safe

(Using Cocoa/OpenStep's NSObject as a base class) <objc> // SomeSingleton.h @interface SomeSingleton : NSObject { 

 // any instance variables

}

+ (SomeSingleton*)sharedInstance;

@end </objc>

<objc> // SomeSingleton.m @implementation SomeSingleton

+ (SomeSingleton*) sharedInstance { 

  static sharedInstance = nil;
  if(!sharedInstance) {
     sharedInstance = [[SomeSingleton alloc] init];
  }
  return sharedInstance;

}

@end </objc>

Java

Thread-safe

Double-checked locking; only use with Java 1.5+ <java> 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

} </java>

Non-Thread-Safe

<java> 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

} </java>

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"

Retrieved from "https://rosettacode.org/wiki/Singleton?oldid=55431"