Одиночка ( англ. Singleton ) — порождающий шаблон проектирования , гарантирующий, что в однопоточном приложении будет единственный экземпляр некоторого класса, и предоставляющий глобальную точку доступа к этому экземпляру.

Цель

У класса есть только один экземпляр, и он предоставляет к нему глобальную точку доступа. При попытке создания данного объекта он создаётся только в том случае, если ещё не существует, в противном случае возвращается ссылка на уже существующий экземпляр и нового выделения памяти не происходит. Существенно то, что можно пользоваться именно экземпляром класса, так как при этом во многих случаях становится доступной более широкая функциональность. Например, к описанным компонентам класса можно обращаться через интерфейс , если такая возможность поддерживается языком.

Глобальный «одинокий» объект — именно объект ( log (). put ( "Test" ); ), а не набор процедур, не привязанных ни к какому объекту ( logPut ( "Test" ); ) — бывает нужен, если:

• Используется существующая объектно-ориентированная библиотека и ей нужен объект, унаследованный от определённого класса/интерфейса.
• Есть шансы, что один объект когда-нибудь превратится в несколько.
• Дополнительные факторы, исполнимые в обеих концепциях, но хорошо сочетающиеся с методикой ООП:
  • Интерфейс объекта (например, игрового мира) слишком сложен, и объект/префикс log служит для организации API.
  • В зависимости от каких-нибудь условий и настроек, создаётся один из нескольких объектов . Например, в зависимости от того, ведётся лог или нет, создаётся настоящий объект, пишущий в файл, или «заглушка», ничего не делающая .
  • Создание объекта занимает время, и для красоты объект можно создавать, когда на экране уже что-то видно.

Такие объекты можно создавать и при инициализации программы. Это может приводить к следующим трудностям:

• Если объект нужен уже при инициализации, он может быть затребован раньше, чем будет создан.
• Бывает, что объект нужен не всегда. В таком случае его создание можно пропустить. Особенно это важно, если одиночек (например, диалоговых окон) много — тогда пользователь быстро получит интерфейс , а окна будут создаваться по одному, не мешая работе пользователя.

Одиночка может принадлежать и не глобальному пространству имён, а какому-то объекту — например, главной форме Qt .

Плюсы

• Наведение порядка в глобальном пространстве имён.
• Ускорение начального запуска программы, если есть множество одиночек, которые не нужны для запуска. Особенно удачно выходит, если создание всех «одиночек» даёт ощутимую задержку, а создание каждого отдельного — практически незаметно.
• Упрощение кода инициализации — система автоматически неявно отделит нужные компоненты от ненужных и проведёт топологическую сортировку .
• Одиночку можно в дальнейшем превратить в шаблон-стратегию или несколько таких объектов.
  • Пример шаблона-стратегии: запись журнала действий в файл или в никуда.
  • Пример нескольких объектов: размножив классы Player и Renderer , можно сделать игру вдвоём на одной машине.

Минусы

• Усложняется контроль за межпоточными гонками и задержками.
  • Многопоточного «одиночку» сложно писать «из головы» : доступ к давно построенному одиночке в идеале не должен открывать мьютекс . Лучше проверенные решения. Как пример см. преамбулу к статье Модель памяти Java .
  • Конфликт двух потоков за недостроенного одиночку приведёт к задержке.
  • Если объект создаётся долго, задержка может мешать пользователю или нарушать реальное время . В таком случае его создание лучше перенести в старт программы.
  • Если программа стартует долго, сложнее становится сделать строку прогресса .
• Требуются особые функции для модульного тестирования , чтобы физически изолировать тесты — например, сделать менеджер одиночек не единственным . Впрочем, одиночками часто являются модули общения с аппаратурой, объектами ОС, программным окружением и пользователем , которые модульному тестированию поддаются плохо.
• Требуется особая тактика тестирования готовой программы, ведь пропадает даже понятие « простейшая запускаемость » — запускаемость зависит от конфигурации.
• Маленький объект без данных — чистый шаблон-стратегию или null object — обычно держат в , а не в динамической памяти , и превращают в одиночку в особых случаях.
• Сами по себе одиночки никак не заведуют порядком выгрузки. Возможна даже ситуация « сборщик мусора уничтожил одиночку, клиент создал нового» . Если этот порядок важен, можно перевести систему на умные указатели или при выходе явно прекратить всю подозрительную деятельность в ключевых компонентах.
• Компоненты не должны иметь неявных связей между собой, иначе небольшое изменение — в программном коде, файле настроек, сценарии пользования — может спутать порядок и вызвать трудноуловимую ошибку. Пример: одиночка А использует COM , но полагается на CoInitialize , вызванный одиночкой Б, и без него работать не может. Решение: сделать одиночку CoInit, который явно используется и А, и Б.
  • Одиночки требуют особого внимания, если один из компонентов заведомо ненадёжен и для адекватной работы требует особых условий («разглючек»): библиотека, которая иногда портит память; сеть, которая разрывает соединение, если слишком долго ждать; типографский движок, способный загрузить шрифты в одном порядке и не способный наоборот… Тогда, в зависимости от порядка инициализации, компонент может сработать адекватно или нет.

Применение

• должен быть ровно один экземпляр некоторого класса, легко доступный всем клиентам;
• единственный экземпляр должен расширяться путём порождения подклассов, и клиентам нужно иметь возможность работать с расширенным экземпляром без модификации своего кода.

Примеры использования

• Ведение отладочного файла для приложения.
• В любом приложении для iOS существует класс AppDelegate, реагирующий на системные события.

Примеры реализации

Java 1.6

public class Singleton {
  private static Singleton instance;
  private Singleton () {};

  public static Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();
    }
    return instance;
  }
}

Java

public class Singleton {
    private volatile Singleton instance;
    private Singleton() {}

    public Singleton getInstance() {
        if (instance == null) {
            synchronized (this) {
                if (instance == null) {
                    return new Singleton();
                }
            }
        }
        return instance;
    }
}

Java

public class Singleton {
  private static Singleton instance;

  static {
    instance = new Singleton();
    // В этом блоке возможна обработка исключений
  }

  private Singleton () {}

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

Java 1.5

public class Singleton {  
   private Singleton() {}

   private static class SingletonHolder {  
      public static final Singleton instance = new Singleton();  
   }  
   
   public static Singleton getInstance()  {  
      return SingletonHolder.instance;  
   }  
}

Java 1.5

public enum SingletonEnum {  
   INSTANCE;

   public void someMethod() {  
      ***
   }  
      
   public void anotherMethod() {  
      ***
   }  
}

Python

Из от 3 июня 2020 на Wayback Machine :

def singleton(cls):
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

@singleton
class MyClass:
    ...

Python

Из от 3 июня 2020 на Wayback Machine ^{[ нет в источнике ]} :

class MetaSingleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(MetaSingleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class MyClass(metaclass=MetaSingleton):
    ...

C++

Ниже приведена одна из возможных реализаций паттерна Одиночка на C++ (известная как синглтон Майерса ), где одиночка представляет собой статический локальный объект. Важным моментом является то, что конструктор класса объявлен как private , что позволяет предотвратить создание экземпляров класса за пределами его реализации. Помимо этого, закрытыми также объявлены конструктор копирования и оператор присваивания. Последние следует объявлять, но не определять, так как это позволяет в случае их случайного вызова из кода получить легко обнаруживаемую ошибку компоновки. Отметим также, что приведенный пример не является потокобезопасным в C++03, для работы с классом из нескольких потоков нужно защитить переменную theSingleInstance от одновременного доступа, например, с помощью мьютекса или критической секции . Впрочем, в C++11 синглтон Майерса является потокобезопасным и без всяких блокировок.

class OnlyOne
{
public:
        static OnlyOne& Instance()
        {
                static OnlyOne theSingleInstance;
                return theSingleInstance;
        }
private:        
        OnlyOne(){}
        OnlyOne(const OnlyOne& root) = delete;
        OnlyOne& operator=(const OnlyOne&) = delete;
};

Ещё один пример реализации одиночки на C++ с возможностью наследования для создания интерфейса, каркасом которого послужит, собственно, одиночка. Временем «жизни» единственного объекта удобно управлять, используя механизм подсчета ссылок .

class Singleton
{
protected:
	static Singleton* _self;
	Singleton() {}
	virtual ~Singleton() {}

public:
	static Singleton* Instance()
	{
		if(!_self)
		{
			_self = new Singleton();
		}
		return _self;
	}

	static bool DeleteInstance()
	{
		if(_self)
		{
			delete _self;
			_self = 0;
			return true;
		}
		return false;
	}
};

Singleton* Singleton ::_self = 0;

C#

public sealed class Singleton
{
    private static readonly Lazy<Singleton> instanceHolder =
        new Lazy<Singleton>(() => new Singleton());

    private Singleton()
    {
        ...
    }

    public static Singleton Instance
    {
        get { return instanceHolder.Value; }
    }
}

/// generic Singleton<T> (потокобезопасный с использованием generic-класса и с отложенной инициализацией)

/// <typeparam name="T">Singleton class</typeparam>
public class Singleton<T> where T : class
{
  /// Защищённый конструктор необходим для того, чтобы предотвратить создание экземпляра класса Singleton. 
  /// Он будет вызван из закрытого конструктора наследственного класса.
  protected Singleton() { }

  /// Фабрика используется для отложенной инициализации экземпляра класса
  private sealed class SingletonCreator<S> where S : class
  {
    //Используется Reflection для создания экземпляра класса без публичного конструктора
    private static readonly S instance = (S) typeof(S).GetConstructor(
                BindingFlags.Instance | BindingFlags.NonPublic,
                null,
                new Type[0],
                new ParameterModifier[0]).Invoke(null);

    public static S CreatorInstance
    {
      get { return instance; }
    }
  }

  public static T Instance
  {
    get { return SingletonCreator<T>.CreatorInstance; }
  }

}

/// Использование Singleton
public class TestClass : Singleton<TestClass>
{
    /// Вызовет защищённый конструктор класса Singleton
    private TestClass() { }

    public string TestProc()
    {
        return "Hello World";
    }
}

public class Singleton
{
  /// защищённый конструктор нужен, чтобы предотвратить создание экземпляра класса Singleton
  protected Singleton() { }

  private sealed class SingletonCreator
  {
    private static readonly Singleton instance = new Singleton();
    public static Singleton Instance { get { return instance; } }
  }

  public static Singleton Instance
  {
    get { return SingletonCreator.Instance; }
  }

}

public class Singleton
{
  private static readonly Singleton instance = new Singleton();

  public static Singleton Instance
  {
    get { return instance; }
  }

  /// защищённый конструктор нужен, чтобы предотвратить создание экземпляра класса Singleton
  protected Singleton() { }  
}

namespace Singleton{
    public class Singleton
    {
        private static Singleton instance;
        public static Singleton Instance
        {
                get
                { 
                        instance ??= new Singleton();
                        return instance;
                }
        }
        protected Singleton() { }
    }
}

PHP 4

<?php
class Singleton {
    
    function Singleton( $directCall = true ) {
        if ( $directCall ) {
            trigger_error("Нельзя использовать конструктор для создания класса Singleton. 
                           Используйте статический метод getInstance()",E_USER_ERROR);
        }
        //TODO: Добавьте основной код конструктора здесь
    }

    function &getInstance() {
        static $instance;
        if ( !is_object( $instance ) ) {
            $class = __CLASS__;
            $instance = new $class( false );
        }
        return $instance;
    }
}

//usage
$test = &Singleton::getInstance();
?>

PHP 5

<?php
 class Singleton {
    private static $instance;  // экземпляр объекта
    private function __construct(){ /* ... @return Singleton */ }  // Защищаем от создания через new Singleton
    private function __clone()    { /* ... @return Singleton */ }  // Защищаем от создания через клонирование
    private function __wakeup()   { /* ... @return Singleton */ }  // Защищаем от создания через unserialize
    public static function getInstance() {    // Возвращает единственный экземпляр класса. @return Singleton
        if ( empty(self::$instance) ) {
            self::$instance = new self();
        }
        return self::$instance;
    }
    public function doAction() { }
 }

/*
Применение
*/
 Singleton::getInstance()->doAction(); //

?>

PHP 5.4

<?php
trait Singleton {
    private static $instance = null;

    private function __construct() { /* ... @return Singleton */ }  // Защищаем от создания через new Singleton
    private function __clone() { /* ... @return Singleton */ }  // Защищаем от создания через клонирование
    private function __wakeup() { /* ... @return Singleton */ }  // Защищаем от создания через unserialize

    public static function getInstance() {
		return 
		self::$instance===null
			? self::$instance = new static() // Если $instance равен 'null', то создаем объект new self()
			: self::$instance; // Иначе возвращаем существующий объект 
    }
}

/**
 * Class Foo
 * @method static Foo getInstance()
 */
class Foo {
    use Singleton;

    private $bar = 0;

    public function incBar() {
        $this->bar++;
    }

    public function getBar() {
        return $this->bar;
    }
}

/*
Применение
*/

$foo = Foo::getInstance();
$foo->incBar();

var_dump($foo->getBar());

$foo = Foo::getInstance();
$foo->incBar();

var_dump($foo->getBar());
?>

Delphi

Для Delphi 2005 и выше подходит следующий пример (не потоко-безопасный):

type
  TSingleton = class
  strict private
    class var
      Instance: TSingleton;
  public
    class function NewInstance: TObject; override;
  end;

class function TSingleton.NewInstance: TObject;
begin
  if not Assigned(Instance) then
    Instance := TSingleton(inherited NewInstance);
  Result := Instance;
end;

Для более ранних версий следует переместить код класса в отдельный модуль, а объявление Instance заменить объявлением глобальной переменной в его секции implementation (до Delphi 7 включительно секции class var и strict private отсутствовали).

Dart

class Singleton {
  static final Singleton _singleton = Singleton._internal();

  factory Singleton() {
    return _singleton;
  }

  Singleton._internal();
}

Io

Singleton := Object clone
Singleton clone := Singleton

Ruby

class Singleton
    def self.new
        @instance ||= super
    end
end

require 'singleton'
class Foo
    include Singleton
end
a = Foo.instance # Foo.new недоступен, для получения ссылки на (единственный)
                 # экземпляр класса Foo следует использовать метод Foo#instance

Common Lisp

(defclass singleton-class () ;;метакласс, реализующий механизм синглтона
  ((instance :initform nil)))

(defmethod validate-superclass ((class singleton-class) (superclass standard-class))
  t) ;;Разрешаем наследование классов-синглтонов от обычных классов

(defmethod validate-superclass ((class singleton-class) (superclass singleton-class))
  t) ;;Разрешаем наследование классов-синглтонов от других классов-синглтонов

(defmethod validate-superclass ((class standard-class) (superclass singleton-class))
  nil) ;;Запрещаем наследование обычных классов от синглтонов

(defmethod make-instance ((class singleton-class) &key) 
  (with-slots (instance) class
    (or instance (setf instance (call-next-method)))))

(defclass my-singleton-class () 
  () 
  (:metaclass singleton-class))

VB.NET

Module Program

    Sub Main()
        Dim T1 As Singleton = Singleton.getInstance
        T1.Value = 1000

        Dim T2 As Singleton = Singleton.getInstance
        Console.WriteLine(T2.Value)

        Console.Read()
    End Sub

End Module

Public Class Singleton

    Public Value As Integer

    'Не разрешаем конструктор
    Protected Sub New()
    End Sub

    Private NotInheritable Class SingletonCreator
        Private Shared ReadOnly m_instance As New Singleton()

        Public Shared ReadOnly Property Instance() As Singleton
            Get
                Return m_instance
            End Get
        End Property
    End Class

    Public Shared ReadOnly Property getInstance() As Singleton
        Get
            Return SingletonCreator.Instance
        End Get
    End Property

End Class

Perl

use v5.10;
use strict;

package Singleton;

sub new {
   # Объявление статической переменной $instance
   # и возврат её как результат выполнения метода new
   state $instance = bless {};
}

package main;

my $a = Singleton->new;
my $b = Singleton->new;

say "$a $b"; # Ссылки $a и $b указывают на один объект

Perl

#!/usr/bin/perl -w

use feature "say";
use strict;
use warnings;
 
package Singleton {
 
    my $instance;    # экземпляр класса (статическое поле)
 
    # -- ** конструктор ** --
    sub new {
        my $class = shift;
        unless($instance) {   # проверяем нет ли уже созданного экземпляра класса
            $instance = {   # если нет, создаем новый и записываем в него имя того, с кем надо поздороваться
                name => shift,
            };
            bless $instance, $class;
        }
        return $instance;   # возвращаем единственный и неповторимый экземпляр нашего класса
    }
    
    # -- ** приветствие ** --
    sub hello {
        my($self) = (shift);
        say "Hello, $self->{name}"; # давайте поприветствуем хозяина этого объекта
    }
}
 
my $a = Singleton->new('Alex');     # создаем экземпляр класса с именем Alex
my $b = Singleton->new('Barney');   # ... а теперь пытаемся создать ещё один экземпляр для Barney
$a->hello();    #   Hello, Alex     # да, здравствуй, Алекс
$b->hello();    #   Hello, Alex     # ой, Барни, извини, какое недоразумение...

ActionScript 3

package
{
	public class Singleton
	{
		private static var _instance:Singleton;

		public function Singleton(privateClass:PrivateClass)
		{
		}
	        
                public static function getInstance():Singleton
                {
			if (!_instance)
				_instance = new Singleton(new PrivateClass());
                        
                        return _instance;
                }
	}
}

// Из-за того, что класс объявлен в том же файле за пределами 
// пакета, использовать его сможет только класс Singleton.
class PrivateClass
{
        public function PrivateClass()
	{
	}
}

package
{
	public class Singleton
	{
		public static const instance:Singleton = new Singleton();

		public function Singleton()
		{
			// Boolean(Singleton) равно false, в случае если экземпляр класса
                        // будет создан до выполнения статического конструктора
			if (Singleton) 
                        	throw new Error("Class is singleton.");
		}
	
	}
}

package {
 
	public class MySingleton {
 
		private static var _instance:MySingleton;
                //Переменная доступа
		private static var _isConstructing:Boolean;
 
		public function MySingleton() {
			if (!_isConstructing) throw new Error("Singleton, use MySingleton.instance");
		}
 
		public static function get instance():MySingleton {
			if (_instance == null)  {
				_isConstructing = true;
				_instance = new MySingleton();
				_isConstructing = false;
			}
			return _instance;
		}
	}
}

CoffeeScript

class Singleton
	instance = undefined
	constructor : ->
		if instance?
			return instance
		else instance = @

		# Код конструктора

console.assert( new Singleton is new Singleton );

class Singleton
	init = -> # конструктор как приватный метод класса
		# Код конструктора
		# ...

		# Заменяем конструктор, сохраняя this (@)
		init = => @
		return @

	# Реальный конструктор. Служит для вызова init
	# return использовать обязательно, иначе вернёт this (@)
	constructor : -> return init.apply(@, arguments)

console.assert( new Singleton is new Singleton )

 constructor : -> Singleton = => @

ns = {}
class ns.Singleton
	constructor : ->
		# Код конструктора

		ns.Singleton = => @

console.assert( new ns.Singleton is new ns.Singleton )

JavaScript

const Singleton = (function() {
  let instance;

  // Приватные методы и свойства

  // Конструктор
  function Singleton() {
    if (instance) return instance;
    instance = this;
  }

  // Публичные методы
  Singleton.prototype.test = function() {};

  return Singleton;
})();

console.log(new Singleton() === new Singleton());

function Singleton() {
  const instance = Singleton.instance;
  if (instance) return instance;
  Singleton.instance = this;
}

Singleton.prototype.test = function() {};

console.log(new Singleton() === new Singleton());

const Singleton = new (function() {
  const instance = this;
  return function() { return instance; };
})();

console.log(new Singleton() === new Singleton());

class Singleton{
    static #onlyInstance = null;
    constructor(){
        if(!Singleton.#onlyInstance){
            Singleton.#onlyInstance = this;
        } else {
            return Singleton.#onlyInstance;
        }
    }
}

console.log(new Singleton() === new Singleton());

Objective-C

@interface Singleton : NSObject {
    
}

+ (Singleton *)sharedInstance;

@end

@implementation Singleton

static Singleton *_sharedInstance = nil;

+ (Singleton *)sharedInstance {
    @synchronized(self) {
        if (!_sharedInstance) {
            _sharedInstance = [[Singleton alloc] init];
        }
    }
    return _sharedInstance;
}

@end

@implementation Singleton

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

@end

Swift

class Singleton {
    static let shared = Singleton()
    private init() { }
}

Scala, Kotlin

object Singleton {} // ключевое слово "object" создает класс, который реализует паттерн "одиночка" по умолчанию

См. также

• Double checked locking

Литература

• Алан Шаллоуей, Джеймс Р. Тротт Шаблоны проектирования. Новый подход к объектно-ориентированному анализу и проектированию = Design Patterns Explained: A New Perspective on Object-Oriented Design. — М.: «Вильямс», 2002. — С. 288. — ISBN 0-201-71594-5 .
• Эрик Фримен, Элизабет Фримен. Паттерны проектирования = Head First Design Patterns. — СПб. : Питер, 2011. — 656 с. — ISBN 978-5-459-00435-9 .

Ссылки

• от 17 февраля 2006 на Wayback Machine — пример использования шаблона (C++).
• от 4 ноября 2005 на Wayback Machine — простое описание с примером применения.
• — описание классической реализации и многопоточные модификации.
• 1 марта 2012 года. — The «Double-Checked Locking is Broken» Declaration in java
• от 7 октября 2010 на Wayback Machine — пример для Perl .
• от 17 декабря 2009 на Wayback Machine — критика паттерна Singleton
• от 17 февраля 2011 на Wayback Machine — фабрика синглтонов.
• от 2 февраля 2012 на Wayback Machine — три варианта реализации на C++.
• (недоступная ссылка) — реализация для Delphi 6/7.

Примечания