Bug #4709 » singleton_docs.diff
| lib/singleton.rb | ||
|---|---|---|
|
require 'thread'
|
||
|
# The Singleton module implements the Singleton pattern.
|
||
|
#
|
||
|
# Usage:
|
||
|
# == Usage
|
||
|
#
|
||
|
# To use Singleton, include the module in your class.
|
||
|
#
|
||
|
# class Klass
|
||
|
# include Singleton
|
||
|
# # ...
|
||
|
# end
|
||
|
#
|
||
|
# * this ensures that only one instance of Klass lets call it
|
||
|
# ``the instance'' can be created.
|
||
|
# This ensures that only one instance of Klass can be created.
|
||
|
#
|
||
|
# a,b = Klass.instance, Klass.instance
|
||
|
# a == b # => true
|
||
|
# Klass.new # NoMethodError - new is private ...
|
||
|
#
|
||
|
# a == b
|
||
|
# # => true
|
||
|
#
|
||
|
# Klass.new
|
||
|
# # => NoMethodError - new is private ...
|
||
|
#
|
||
|
# * ``The instance'' is created at instantiation time, in other
|
||
|
# words the first call of Klass.instance(), thus
|
||
|
# The instance is created at upon the first call of Klass.instance().
|
||
|
#
|
||
|
# class OtherKlass
|
||
|
# include Singleton
|
||
|
# # ...
|
||
|
# end
|
||
|
# ObjectSpace.each_object(OtherKlass){} # => 0.
|
||
|
#
|
||
|
# * This behavior is preserved under inheritance and cloning.
|
||
|
# ObjectSpace.each_object(OtherKlass){}
|
||
|
# # => 0
|
||
|
#
|
||
|
# OtherKlass.instance
|
||
|
# ObjectSpace.each_object(OtherKlass){}
|
||
|
# # => 1
|
||
|
#
|
||
|
#
|
||
|
# This is achieved by marking
|
||
|
# * Klass.new and Klass.allocate - as private
|
||
|
# This behavior is preserved under inheritance and cloning.
|
||
|
#
|
||
|
# Providing (or modifying) the class methods
|
||
|
# * Klass.inherited(sub_klass) and Klass.clone() -
|
||
|
# to ensure that the Singleton pattern is properly
|
||
|
# inherited and cloned.
|
||
|
# == Implementation
|
||
|
#
|
||
|
# * Klass.instance() - returning ``the instance''. After a
|
||
|
# successful self modifying (normally the first) call the
|
||
|
# method body is a simple:
|
||
|
# This above is achieved by:
|
||
|
#
|
||
|
# def Klass.instance()
|
||
|
# return @singleton__instance__
|
||
|
# end
|
||
|
# * Making Klass.new and Klass.allocate private.
|
||
|
#
|
||
|
# * Klass._load(str) - calling Klass.instance()
|
||
|
# * Overriding Klass.inherited(sub_klass) and Klass.clone() to ensure that the
|
||
|
# Singleton properties are kept when inherited and cloned.
|
||
|
#
|
||
|
# * Klass._instantiate?() - returning ``the instance'' or
|
||
|
# nil. This hook method puts a second (or nth) thread calling
|
||
|
# Klass.instance() on a waiting loop. The return value
|
||
|
# signifies the successful completion or premature termination
|
||
|
# of the first, or more generally, current "instantiation thread".
|
||
|
# * Providing the Klass.instance() method that returns the same object each
|
||
|
# time it is called.
|
||
|
#
|
||
|
# * Overriding Klass._load(str) to call Klass.instance().
|
||
|
#
|
||
|
# The instance method of Singleton are
|
||
|
# * clone and dup - raising TypeErrors to prevent cloning or duping
|
||
|
# * Overriding Klass#clone and Klass#dup to raise TypeErrors to prevent
|
||
|
# cloning or duping.
|
||
|
#
|
||
|
# == Singleton and Marshal
|
||
|
#
|
||
|
# By default Singleton's #_dump(depth) returns the empty string. Marshalling by
|
||
|
# default will strip state information, e.g. instance variables and taint
|
||
|
# state, from the instance. Classes using Singleton can provide custom
|
||
|
# _load(str) and _dump(depth) methods to retain some of the previous state of
|
||
|
# the instance.
|
||
|
#
|
||
|
# require 'singleton'
|
||
|
#
|
||
|
# class Example
|
||
|
# include Singleton
|
||
|
# attr_accessor :keep, :strip
|
||
|
# def _dump(depth)
|
||
|
# # this strips the @strip information from the instance
|
||
|
# Marshal.dump(@keep, depth)
|
||
|
# end
|
||
|
#
|
||
|
# def self._load(str)
|
||
|
# instance.keep = Marshal.load(str)
|
||
|
# instance
|
||
|
# end
|
||
|
# end
|
||
|
#
|
||
|
# a = Example.instance
|
||
|
# a.keep = "keep this"
|
||
|
# a.strip = "get rid of this"
|
||
|
# a.taint
|
||
|
#
|
||
|
# stored_state = Marshal.dump(a)
|
||
|
#
|
||
|
# a.keep = nil
|
||
|
# a.strip = nil
|
||
|
# b = Marshal.load(stored_state)
|
||
|
# p a == b # => true
|
||
|
# p a.keep # => "keep this"
|
||
|
# p a.strip # => nil
|
||
|
#
|
||
|
# * _dump(depth) - returning the empty string. Marshalling strips
|
||
|
# by default all state information, e.g. instance variables and
|
||
|
# taint state, from ``the instance''. Providing custom _load(str)
|
||
|
# and _dump(depth) hooks allows the (partially) resurrections of
|
||
|
# a previous state of ``the instance''.
|
||
|
require 'thread'
|
||
|
module Singleton
|
||
|
# disable build-in copying methods
|
||
|
# Raises a TypeError to prevent cloning.
|
||
|
def clone
|
||
|
raise TypeError, "can't clone instance of singleton #{self.class}"
|
||
|
end
|
||
|
# Raises a TypeError to prevent duping.
|
||
|
def dup
|
||
|
raise TypeError, "can't dup instance of singleton #{self.class}"
|
||
|
end
|
||
|
# default marshalling strategy
|
||
|
# By default, do not retain any state when marshalling.
|
||
|
def _dump(depth = -1)
|
||
|
''
|
||
|
end
|
||
|
module SingletonClassMethods
|
||
|
# properly clone the Singleton pattern - did you know
|
||
|
# that duping doesn't copy class methods?
|
||
|
def clone
|
||
|
module SingletonClassMethods # :nodoc:
|
||
|
def clone # :nodoc:
|
||
|
Singleton.__init__(super)
|
||
|
end
|
||
|
# By default calls instance(). Override to retain singleton state.
|
||
|
def _load(str)
|
||
|
instance
|
||
|
end
|
||
|
private
|
||
|
# ensure that the Singleton pattern is properly inherited
|
||
|
def inherited(sub_klass)
|
||
|
super
|
||
|
Singleton.__init__(sub_klass)
|
||
|
end
|
||
|
end
|
||
|
class << Singleton
|
||
|
def __init__(klass)
|
||
|
class << Singleton # :nodoc:
|
||
|
def __init__(klass) # :nodoc:
|
||
|
klass.instance_eval {
|
||
|
@singleton__instance__ = nil
|
||
|
@singleton__mutex__ = Mutex.new
|
||
|
}
|
||
|
def klass.instance
|
||
|
def klass.instance # :nodoc:
|
||
|
return @singleton__instance__ if @singleton__instance__
|
||
|
@singleton__mutex__.synchronize {
|
||
|
return @singleton__instance__ if @singleton__instance__
|
||
| ... | ... | |
|
private
|
||
|
# extending an object with Singleton is a bad idea
|
||
|
# extending an object with Singleton is a bad idea
|
||
|
undef_method :extend_object
|
||
|
def append_features(mod)
|
||
| ... | ... | |
|
def included(klass)
|
||
|
super
|
||
|
klass.private_class_method :new, :allocate
|
||
|
klass.private_class_method :new, :allocate
|
||
|
klass.extend SingletonClassMethods
|
||
|
Singleton.__init__(klass)
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
if __FILE__ == $0
|
||
|
def num_of_instances(klass)
|
||
|
"#{ObjectSpace.each_object(klass){}} #{klass} instance(s)"
|
||
|
end
|
||
|
# The basic and most important example.
|
||
|
class SomeSingletonClass
|
||
|
include Singleton
|
||
|
end
|
||
|
puts "There are #{num_of_instances(SomeSingletonClass)}"
|
||
|
a = SomeSingletonClass.instance
|
||
|
b = SomeSingletonClass.instance # a and b are same object
|
||
|
puts "basic test is #{a == b}"
|
||
|
begin
|
||
|
SomeSingletonClass.new
|
||
|
rescue NoMethodError => mes
|
||
|
puts mes
|
||
|
end
|
||
|
puts "\nThreaded example with exception and customized #_instantiate?() hook"; p
|
||
|
Thread.abort_on_exception = false
|
||
|
class Ups < SomeSingletonClass
|
||
|
def initialize
|
||
|
self.class.__sleep
|
||
|
puts "initialize called by thread ##{Thread.current[:i]}"
|
||
|
end
|
||
|
end
|
||
|
class << Ups
|
||
|
def _instantiate?
|
||
|
@enter.push Thread.current[:i]
|
||
|
while false.equal?(@singleton__instance__)
|
||
|
@singleton__mutex__.unlock
|
||
|
sleep 0.08
|
||
|
@singleton__mutex__.lock
|
||
|
end
|
||
|
@leave.push Thread.current[:i]
|
||
|
@singleton__instance__
|
||
|
end
|
||
|
def __sleep
|
||
|
sleep(rand(0.08))
|
||
|
end
|
||
|
def new
|
||
|
begin
|
||
|
__sleep
|
||
|
raise "boom - thread ##{Thread.current[:i]} failed to create instance"
|
||
|
ensure
|
||
|
# simple flip-flop
|
||
|
class << self
|
||
|
remove_method :new
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
def instantiate_all
|
||
|
@enter = []
|
||
|
@leave = []
|
||
|
1.upto(9) {|i|
|
||
|
Thread.new {
|
||
|
begin
|
||
|
Thread.current[:i] = i
|
||
|
__sleep
|
||
|
instance
|
||
|
rescue RuntimeError => mes
|
||
|
puts mes
|
||
|
end
|
||
|
}
|
||
|
}
|
||
|
puts "Before there were #{num_of_instances(self)}"
|
||
|
sleep 3
|
||
|
puts "Now there is #{num_of_instances(self)}"
|
||
|
puts "#{@enter.join '; '} was the order of threads entering the waiting loop"
|
||
|
puts "#{@leave.join '; '} was the order of threads leaving the waiting loop"
|
||
|
end
|
||
|
end
|
||
|
Ups.instantiate_all
|
||
|
# results in message like
|
||
|
# Before there were 0 Ups instance(s)
|
||
|
# boom - thread #6 failed to create instance
|
||
|
# initialize called by thread #3
|
||
|
# Now there is 1 Ups instance(s)
|
||
|
# 3; 2; 1; 8; 4; 7; 5 was the order of threads entering the waiting loop
|
||
|
# 3; 2; 1; 7; 4; 8; 5 was the order of threads leaving the waiting loop
|
||
|
puts "\nLets see if class level cloning really works"
|
||
|
Yup = Ups.clone
|
||
|
def Yup.new
|
||
|
begin
|
||
|
__sleep
|
||
|
raise "boom - thread ##{Thread.current[:i]} failed to create instance"
|
||
|
ensure
|
||
|
# simple flip-flop
|
||
|
class << self
|
||
|
remove_method :new
|
||
|
end
|
||
|
end
|
||
|
end
|
||
|
Yup.instantiate_all
|
||
|
puts "\n\n","Customized marshalling"
|
||
|
class A
|
||
|
include Singleton
|
||
|
attr_accessor :persist, :die
|
||
|
def _dump(depth)
|
||
|
# this strips the @die information from the instance
|
||
|
Marshal.dump(@persist,depth)
|
||
|
end
|
||
|
end
|
||
|
def A._load(str)
|
||
|
instance.persist = Marshal.load(str)
|
||
|
instance
|
||
|
end
|
||
|
a = A.instance
|
||
|
a.persist = ["persist"]
|
||
|
a.die = "die"
|
||
|
a.taint
|
||
|
stored_state = Marshal.dump(a)
|
||
|
# change state
|
||
|
a.persist = nil
|
||
|
a.die = nil
|
||
|
b = Marshal.load(stored_state)
|
||
|
p a == b # => true
|
||
|
p a.persist # => ["persist"]
|
||
|
p a.die # => nil
|
||
|
puts "\n\nSingleton with overridden default #inherited() hook"
|
||
|
class Up
|
||
|
end
|
||
|
def Up.inherited(sub_klass)
|
||
|
puts "#{sub_klass} subclasses #{self}"
|
||
|
end
|
||
|
class Middle < Up
|
||
|
include Singleton
|
||
|
end
|
||
|
class Down < Middle; end
|
||
|
puts "and basic \"Down test\" is #{Down.instance == Down.instance}\n
|
||
|
Various exceptions"
|
||
|
begin
|
||
|
module AModule
|
||
|
include Singleton
|
||
|
end
|
||
|
rescue TypeError => mes
|
||
|
puts mes #=> Inclusion of the OO-Singleton module in module AModule
|
||
|
end
|
||
|
begin
|
||
|
'aString'.extend Singleton
|
||
|
rescue NoMethodError => mes
|
||
|
puts mes #=> undefined method `extend_object' for Singleton:Module
|
||
|
end
|
||
|
##
|
||
|
# :singleton-method: _load
|
||
|
# By default calls instance(). Override to retain singleton state.
|
||
|
end
|
||