[Design Pattern]GoF 의 Design Pattern - Creational Patterns - Singleton
Definition
Ensure a class has only one instance and provide a global point of access to it.
|
분류 |
설명 |
|
이름(Name) |
Singleton |
|
의도(Insert) |
클래스에서 만들 수 있는 인스턴스가 오직 하나일 경우에 이에 대한 접근은 어디에서든지 하나로만 통일하여 제공한다. |
|
문제점(Problem) |
|
|
해결법(Solution) |
|
|
관계자(Participant)와 협력자(Collaborator) |
Abstract Factory, Builder, Prototype |
|
결과(Consequence) |
Singleton 패턴이 갖는 장점들을 보면 다음과 같다. 1. 유일하게 존재하는 인스턴스로의 접근을 통제할 수 있다. 2. 변수 영역을 줄인다. Singleton 패턴은 전역 변수보다 장점이 있는데, 그것은 전역 변수를 사용해서 변수 영역을 망치는 일을 없애 준다는 것이다. 3. 오퍼레이션의 정제를 가능하게 한다. Singleton 클래스는 상속 될 수 있기 때문에, 이 상속된 서브 클래스를 통해서 새로운 인스턴스를 만들 수 있다. 4. 인스턴스의 개수를 변경하기가 자유롭다. Singleton클래스의 인스턴스가 하나 이상 존재할 수 있도록 변경해야 하는 경우도 있다. 애플리케이션에 존재하는 인스턴스가 다수여야 하는 경우도 하나가 존재해야 하는 경우와 동일한 방법으로 해결하는 것이다. 5. 클래스 오퍼레이션을 사용하는 것보다 훨씬 유연한 방법이다. 싱글톤과 동일한 기능을 발휘하게 하는 방법이 클래스 오퍼레이션을 사용하는 방법이다. C++에서는 정적 멤버 함수를, 스몰토크에서는 클래스 메소드를 제공한다. 이 들 두언어 모두에서는 클래스의 인스턴스가 하나 이상 존재할 수 있도록 설계를 변경하는 것이 어렵다. 함수가 되면 서브클래스들이 이 오퍼레이션을 상속하여 다형성을 지원하도록 재졍의할 수 없기 때문이다. |
|
구현(Implementation) |
Singletone 패턴을 사용하여 구현할 때의 고려 사항을 살펴보면 다음과 같다. 1. 인스턴스가 유일해야 함을 보장한다. Singleton패턴은 클래스의 인스턴스가 오로지 하나임을 만족해야 한다. 가장 일반적인 방법은 인스턴스를 생성하는 오퍼레이션을 클래스 오퍼레이션으로 만드는 것이다. 이 오퍼레이션은 유일한 인스턴스를 관리할 변수에 접근해서 이 변수에 유일한 인스턴스로 초기화 하고 이 변수를 되돌려 줌으로써 클라이언트가 유일한 인스턴스를 사용할 수 있도록 한다. 2. Singletone 클래스를 상속 받는다. 서브클래스를 만드는 것이 주용한 게 아니라, 이 새로운 서브클래스의 유일한 인스턴스를 만들어 클라이언트가 이를 사용할 수 있또록 하는 것이다. Singleton의 인스턴스를 이들 서브 클래스의 인스턴스로 초기화 해야 한다. |
UML class diagram
Participants
The classes and/or objects participating in the Singleton pattern are:
- Singleton (LoadBalancer)
- defines an Instance operation that lets clients access its unique instance. Instance is a class operation.
- responsible for creating and maintaining its own unique instance
Sample code in C#
This structural code demonstrates the Singleton pattern which assures only a single instance (the singleton) of the class can be created
|
// Singleton pattern -- Structural example
//-------------------------------------------------------- // Copyright (C) 2001 - 2002, Data & Object Factory // All rights reserved. www.dofactory.com // // You are free to use this source code in your // applications as long as the original copyright // notice is included. // // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT // WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, // INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF // MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. //--------------------------------------------------------
using System;
// "Singleton"
class Singleton { // Fields private static Singleton instance;
// Constructor protected Singleton() {}
// Methods public static Singleton Instance() { // Uses "Lazy initialization" if( instance == null ) instance = new Singleton();
return instance; } }
/// <summary> /// Client test /// </summary> public class Client { public static void { // Constructor is protected -- cannot use new Singleton s1 = Singleton.Instance(); Singleton s2 = Singleton.Instance();
if( s1 == s2 ) Console.WriteLine( "The same instance" );
Console.Read(); } }
Output Objects are the same instance |
This real-world code demonstrates the Singleton pattern as a LoadBalancing object. Only a single instance (the singleton) of the class can be created because servers may dynamically come on- or off-line and every request must go throught the one object that has knowledge about the state of the (web) farm.
|
// Singleton pattern
//-------------------------------------------------- // Copyright (C) 2001, Data & Object Factory // All rights reserved. www.dofactory.com // // You are free to use this source code in your // applications, although it is intended only for // educational purposes. // // THIS CODE AND INFORMATION IS PROVIDED "AS IS" // WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE // IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR // FITNESS FOR A PARTICULAR PURPOSE. //--------------------------------------------------
using System; using System.Collections; using System.Threading;
// "Singleton"
class LoadBalancer { // Fields private static LoadBalancer balancer; private ArrayList servers = new ArrayList(); private Random random = new Random();
// Constructors (protected) protected LoadBalancer() { // List of available servers servers.Add( "ServerI" ); servers.Add( "ServerII" ); servers.Add( "ServerIII" ); servers.Add( "ServerIV" ); servers.Add( "ServerV" ); }
// Methods public static LoadBalancer GetLoadBalancer() { // Support multithreaded applications through // "Double checked locking" pattern which avoids // locking every time the method is invoked if( balancer == null ) { // Only one thread can obtain a mutex Mutex mutex = new Mutex(); mutex.WaitOne();
if( balancer == null ) balancer = new LoadBalancer();
mutex.Close(); }
return balancer; }
// Properties public string Server { get { // Simple, but effective random load balancer int r = random.Next( servers.Count ); return servers[ r ].ToString(); } } }
/// <summary> /// SingletonApp test /// </summary> /// public class SingletonApp { public static void { LoadBalancer b1 = LoadBalancer.GetLoadBalancer(); LoadBalancer b2 = LoadBalancer.GetLoadBalancer(); LoadBalancer b3 = LoadBalancer.GetLoadBalancer(); LoadBalancer b4 = LoadBalancer.GetLoadBalancer();
// Same instance? if( (b1 == b2) && (b2 == b3) && (b3 == b4) ) Console.WriteLine( "Same instance" );
// Do the load balancing Console.WriteLine( b1.Server ); Console.WriteLine( b2.Server ); Console.WriteLine( b3.Server ); Console.WriteLine( b4.Server );
Console.Read(); } }
Output Same instance
ServerIII ServerII ServerI ServerII ServerI ServerIII ServerI ServerIII ServerIV ServerII ServerII ServerIII ServerIV ServerII ServerIV |
