Singleton

Diagrama UML de uma classe singleton.

Singleton, é um padrão de projeto de software (do inglês Design Pattern). Este padrão garante a existência de apenas uma instância de uma classe, mantendo um ponto global de acesso ao seu objeto.

Nota linguística: O termo vem do significado em inglês quando se resta apenas uma carta nas mãos, num jogo de baralho.

Muitos projetos necessitam que algumas classes tenham apenas uma instância. Por exemplo, em uma aplicação que precisa de uma infraestrutura de log de dados, pode-se implementar uma classe no padrão singleton. Desta forma existe apenas um objeto responsável pelo log em toda a aplicação que é acessível unicamente através da classe singleton.

Onde Usar

Quando você necessita de somente uma instância da classe, por exemplo, a conexão com banco de dados, vamos supor que você terá que chamar diversas vezes a conexão com o banco de dados em um código na mesma execução, se você instanciar toda vez a classe de banco, haverá grande perda de desempenho, assim usando o padrão singleton, é garantida que nesta execução será instânciada a classe somente uma vez. Lembrando que este pattern é considerado por muitos desenvolvedores um anti-pattern, então, cuidado onde for utilizá-lo. Onde se trata de pools de conexão, saídas gráficas, impressão, objetos que cuidam de registros ou de logs não devem ser instanciados mais de uma vez!

Exemplos

Em Java

Segue um exemplo em Java de uma classe Singleton.

 public final class MySingleton {
     // Instancia estática privada que será acessada
     private static final MySingleton INSTANCE = new MySingleton();

     // Construtor privado. Suprime o construtor público padrao.
     private MySingleton() {
          // Operações de inicialização da classe
     }

     // Método público estático de acesso único ao objeto!
     public static MySingleton getInstance(){
           return INSTANCE;
     }
 }

Em C++

Segue um exemplo em C++ da implementação de uma classe Singleton:

 class MyClass
 {
    private:
       // atributo estático da "instância única"
       static MyClass *instance = 0;
       //construtor privado, não pode ser utilizado fora da classe 
       MyClass() {}
 
    public:
       // Função-membro que retorna sempre a mesma instância do objeto
       static MyClass& getInstance()
       {
          if (!instance) instance = new MyClass();
          return *instance;
       }
 };

Em Delphi

Abaixo segue um exemplo de como implementar uma classe Singleton:

Por exemplo, numa classe Fachada, onde se encontra todos os métodos disponíveis para a interface da aplicação, pode ser criado um método dinâmico para que todos os que visualizam essa classe, não criarem mais instâncias da mesma.

 class function TFachada.ObterInstancia: TFachada;
 begin
   If FInstance = nil Then
     FInstance := Cliente.Fachada.TFachada.Create();//objeto instanciado através do Finstance  
   Result := FInstance;//retorna o objeto
 end;

Em PHP

<?php
class Singleton
{
	private static $_instance;
        
        // Evita que a classe seja instanciada publicamente
        private function __construct() { }

	// Evita que a classe seja clonada
        private function __clone() { }

	public static function getInstance()
	{
		if (!isset(self::$_instance)) { // Testa se há instância definifa na propriedade, caso sim, a classe não será instanciada novamente.
			self::$_instance = new self; // o new self cria uma instância da própria classe à própria classe.
		}
		return self::$_instance;
	}
}

Em Ruby

class Classe
    include Singleton
end

Em VB.NET

 Public Class MyClass
    Private Shared _instancia As MyClass
    Private Shared objetoSincronia As New Object
    
    Private Sub New()
    End Sub
    
    Public Shared Function getInstancia() As MyClass
        If _instancia Is Nothing Then
            SyncLock objetoSincronia
                If _instancia Is Nothing Then _instancia = New MyClass
            End SyncLock
        End If
        Return _instancia
    End Function
 End Class

Em ActionScript 3

package{
	public class ExemploSingleton {
		private static var instance:ExemploSingleton;
		
		public function ExemploSingleton(enforcer:SingletonEnforcer) : void {
			if (enforcer == null)
				throw new Error("Só pode haver uma instância de ExemploSingleton");
		}

		public static function getInstance() : ExemploSingleton {
			if (instance == null)
				instance = new ExemploSingleton( new SingletonEnforcer );
			return instance;
		}
	}
}
//Para bloquear o acesso ao constructor.
class SingletonEnforcer {

}

Em c# (utilizando Generics)

public sealed class GenericSingleton<T> where T : class, new()
{
    private static T _instance;

    public static T GetInstance()
    {
        lock (typeof(T))
        {
            if (_instance == null)
                _instance = new T();

            return _instance;
        }
    }
}

// Teste do padrão Singleton
public class Car { public int Color { get; set; } }
public class Person { public string Name { get; set; } }

class Program
{
    static void Main(string[] args)
    {
        Car car = GenericSingleton<Car>.GetInstance();
        car.Color = 1;

        Person per = GenericSingleton<Person>.GetInstance();
        per.Name = "John";

        Car car2 = GenericSingleton<Car>.GetInstance();
        car.Color = 2;
    }
}

Obs: Esta solução não impede a criação de múltiplas instâncias das classes Car e Person. Como a classe genérica GenericSingleton obriga que as classes passadas no parâmetro T tenham um construtor público, é possível criar instâncias em qualquer trecho de código através de construções do tipo: Car car3 = new Car();.

Referências

Aula sobre design patterns - Singleton | url: http://www.clubedaprogramacao.com Predefinição:Gigantes de TI

Exemplo do uso de Singleton em aplicativo JSE | url: http://www.patternizando.com.br