후니훈의 모바일 세상

출저: http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=1040201&docId=69965713

출처 - http://snowbora.com/442

=======================================================================

Singleton Pattern - 디자인 패턴

참고서적 :  Head First Design Pattern

소스코드 다운로드 : http://www.wickedlysmart.com/headfirstdesignpatterns/code.html

패턴 정의 #6 - Singleton Pattern

싱글턴 패턴 (Singleton Pattern)은 해당 클래스의 인스턴스가 하나만 만들어지고,

어디서든지 인스턴스에 접근할 수 있도록 하기 위한 패턴입니다.  

가장 널리 사용하는 디자인 패턴이 아닌가 합니다.

굳이 디자인 패턴을 모르더라도 자바 프로그래밍에서 자주 사용하기도 하죠~~  

싱글턴 패턴은 클래스에서 자신의 단 하나뿐인 인스턴스를 관리하도록 만들면 됩니다.

그리고 다른 어떤 클래스에서도 자신의 인스턴스를 추가로 만들지 못하도록 해야 합니다.

인스턴스가 필요하면 반드시 클래스 자신을 거치도록 해야 되겠죠..

- uniqueInstance 클래스 변수에 싱글턴의 유일무이한 인스턴스가 저장됩니다.

- getInstance() 메소드는 정적 메소드, 즉 클래스 메소드입니다.

그냥 Singleton.getInstance() 라는 코드만 사용하면 언제 어디서든 이 메소드를 호출할 수 있습니다.

전역 변수에 접근하는 것만큼이나 쉬우면서도 게으른 인스턴스 생성을 활용할 수 있다는 장점을 제공합니다.

- 싱글턴 패턴을 구현한다고 해서 여기 있는 Singleton 클래스처럼 간단해야 하는 것은 아닙니다.

그냥 일반적인 클래스를 만들 때와 마찬가지로 다양한 데이터와 메소드를 사용할 수 있습니다.

싱글턴 패턴을 사용할 경우, 한가지 고려해야 할 사항이 바로 멀티스레딩 관련 문제입니다.

두 개의 쓰레드가 동시에 생성할 경우, 인스턴스가 두 개 생길 수도 있다는 것이죠..

그래서 이에 대한 해결책으로 다음과 같은 세가지 방법을 사용합니다.

참고하시기 바랍니다.

1. synchronized 키워드를 사용한다.

synchronized로 동기화 하게 되면 비용 측면에서의 문제가 발생할 수 있으므로

getInstance()의 속도가 그리 중요하지 않을 경우, 사용해야 한다고 합니다.

2. 인스턴스를 필요할 때 생성하지 말고, 처음부터 만들어 버린다.

실행중에 만들지 않고 처음부터 Singleton 인스턴스를 만드는 방법입니다.

클래스가 로딩 될 때, JVM에서 Singleton의 유일한 인스턴스를 생성한다고 합니다.

그러므로 JVM에서 유일한 인스턴스를 생성하기 전에는 어떤 쓰레드도 uniqueInstance 변수에 접근할 수 없습니다.

3. DCL(Double Checking Locking)을 써서 getInstance()에서 동기화 되는 부분에 대한 체크를 줄입니다.

DCL은 Java 5 이전 버전에는 사용할 수 없습니다. 즉, 1.4 버전에서는 지원이 안된다는 것이죠~

어쨌든 동기화를 체크하는 부분이 처음에만 이루어지므로 성능에 큰 영향을 주지 않게 됩니다.

volatile 키워드를 사용하면 멀티쓰레딩을 쓰더라도 uniqueInstance 변수가 Singleton 인스턴스로 초기화 되는 과정이 올바르게 진행되도록 할 수 있습니다.

참조 - http://www.word.pe.kr/bbs/view.php?id=lecture&no=29


=============================================================================================

I. Singleton 이란?

아마 GOF의 32가지 패턴 중 가장 쉬우면서도 가장 자주 쓰이게 되며, 가장 문제가 될 소지를 가지는 패턴을 말하면 Singleton을 말할 수 있지 않을까 합니다.

먼저 Singleton 패턴의 용도는 하나의 프로그램 내에서 하나의 인스턴스만을 생성해야만 하는 상황. 예를 들어 환경설정을 관리하는 클래스나
Connection Pool, Thread Pool과 같이 풀(Pool) 형태로 관리되는 클래스의 경우 프로그램 내에서 단 하나의 인스턴스로 관리되는 것이 일반적이며, 이 때 Singleton 패턴을 적용하는 것이 일반적인 경우라고 볼수 있겠습니다. 그럼 세부적인 구현 형태를 살펴 보도록 하겠습니다.

II. Singleton 구현

Singleton 패턴의 가장 일반적인 형태는 다음과 같습니다.

<일반적인 Singleton class diagram>

중요하게 보아야 할 곳은 생성자가 private으로 선언되어 있다는 것이죠. 이유는 간단하게도 클래스 외부에서 이 클래스를 직접 new 키워드로 생성하지 못하게 막겠다는 의미가 되겠습니다. Singleton 패턴은 설명보다는 코드로 보는 것이 훨씬 간결하므로 다음 코드를 보도록 하겠습니다.

1. Singleton 패턴 

2. class Singleton { 

3. private static Singleton instance;

4. private Singleton(){ 

5. } 

6. public static Singleton getInstance(){ 

7. if (instance == null) 

8. instance = new Singleton();  

9. return instance; 

10. } 

11. }

   위 코드에서 파란색으로 표기된 선언부에 집중해야 합니다. Singleton 클래스의 인스턴스를 외부에서 사용하기 위해서는 항상 getInstance 메소드를 호출해야만 하도록 강제된 것을 확인하실 수 있습니다.  위와 같은 경우 getInstance가 호출될 때 객체가 생성되는데 최초 로딩 시에 객체를 생성해 두는 것이 효율적인 경우에는 다음과 같이 멤버 변수를 선언하는 곳에서 직접 생성하는 방법을 이용할 수 있습니다.

1. ClassLoader에 의해 미리 인스턴스를 생성하는 방법 
2. class Singleton { 
3. private static Singleton instance = new Singleton(); 
4. private Singleton(){} 
5. public static Singleton getInstance(){ 
6. if (instance == null) 
7. instance = new Singleton(); 
8. return instance; 
9. } 
10. } 

위의 코드에서 붉은색으로 표기된 멤버 변수 선언부를 보면 new 키워드에 의해 static으로 선언된 멤버 변수의 인스턴스를 미리 생성하는 것을 볼 수 있습니다.

다중 쓰레드 프로그래밍에 필요한 것이 아니라면 위의 코드만으로도 완성된 코드라고 볼수 있겠습니다. 미리 인스턴스를 생성할 필요가 없는 경우에는 이전의 방법을 이용하는데 그런한 방식을 lazy(게으른) 방식이라고 이야기 합니다.

다중 쓰레드 프로그래밍에서는 동기화를 이용한 적절한 수정이 필요한데 많은 커뮤니티에서 그에 따른 예제 코드가 잘 나와있습니다.

(Singleton의 다양한 형태 : http://www.anfamily.net/mcsong/70)

위의 블로그에 방문하시면 싱글톤 패턴의 다양한 종류와 그에 따른 장단점이 잘 분류되어 있습니다.

다만 좀더 자세히 내용을 들여다 보면 가장 간단한 방법이 오히려 득이 되는 경우를 찾을 수 있을 것 입니다. 다음 코드를 봐주세요.

1. Instance의 생성은 단 한번만

2. class Singleton{

3. private static Singleton instance = new Singleton();

4. private Singleton(){}

5. public static Singleton getInstance(){

6. return instance;

7. }

8. }

위의 코드의 녹색으로 표시된 부분을 봐주세요. Simple is best 라는 말 처럼 위의 코드는 Thread-safe하게 잘 만들어진 코드라고 할 수 있겠습니다.

이 클래스는 전체 라이프 타임 중에서 단 한번만 객체를 생성하고 다시는 생성하지 않습니다. 여러개의 쓰레드가 접근을 한다고 하더라도 인스턴스가 두개 이상 생성되거나 Null값을 리턴 받을 염려도 생성자가 두번 호출 되는 경우도 없죠. 

===================================================================================

싱글톤(Singleton) Pattern 이란?



객체지향형언어(OOP)에 대해 조금이라도 파고든 사람이라면 싱글톤 패턴이라는 

말을 들어봤을 것이다. 못들어봤다면 이제부터 들었다고 해라. 싱글톤이란 생성하고자 

하는 인스턴스의 수를 오직 하나로 제한하는 디자인 패턴이다.



그렇다면 왜 싱글톤 패턴을 사용해야하는 것일까? 라는 질문에 대게 답하는 것이

여러개의 인스턴스를 생성하게 되면 가끔 프로그래머도 당혹스럽게 되는 서로의

인스턴스에 간섭을 하는 경우가 있다. 정말 재수 없는 일이 아닐 수가 없다.





public class Singleton

{

private static Singleton singleton = new Singleton();

protected Singleton()

{

System.out.println("Maked Singleton");

}

public static Singleton getInstance()

{

return singleton;

}

}



싱글톤의 기본형이다. singleton 멤버변수는 static 이어야한다는 것과 Singleton 클래스의

생성자는 private / protected 이어야한다는 것을 꼭 유념해야한다. private 일 경우는 결코

new 를 이용하여 인스턴스의 중복 생성을 방지하는 셈이기도 하나 상속이 되지 않는다는

단점이 있어 protected로 대게 선언한다.



뭐~ 싱글톤 패턴이 만들어졌나 아닌가 확인할 것이라면 Test 클래스를 만들어보자.



public class Test

{

public static void main(String [] args)

{

System.out.println("Singleton pattern");

Singleton sg1=Singleton.getInstance();

Singleton sg2=Singleton.getInstance();

if( sg1 == sg2 )

{

System.out.println("Equal");

}

else

{

System.out.println("Not Equal");

}

}

}



여기서 보면 Singleton 의 인스턴스를 생성하기 위해 getInstance() 메소드를 이용한다.

왜 그럴까? Singleton 클래스의 private static Singleton singleton = new Singleton(); 

부분을 유심히 바라보기 바란다. 이 singleton은 static으로 선언된다. 즉 하나의 인스턴스

singleton 만 생성하는 셈이다. 아마 결과도 Equal로 출력될 것이다.

출처 - http://coolx.net/cboard/read.jsp?db=develop&mode=read&num=261

출저 : linuxism.tistory.com/14

싱글톤 패턴의 여러형태  개발 / Study  2010/02/09 11:34 http://blog.naver.com/k1qpo/99745837 전용뷰어 보기

In this tutorial, it shows the use of java.lang.Comparable and java.util.Comparator to sort a Java object based on its property value.

1. Sort an Array

To sort an Array, use the Arrays.sort().

	String[] fruits = new String[] {"Pineapple","Apple", "Orange", "Banana"}; 
 
	Arrays.sort(fruits);
 
	int i=0;
	for(String temp: fruits){
		System.out.println("fruits " + ++i + " : " + temp);
	}

Output

fruits 1 : Apple
fruits 2 : Banana
fruits 3 : Orange
fruits 4 : Pineapple

2. Sort an ArrayList

To sort an ArrayList, use the Collections.sort().

	List<String> fruits = new ArrayList<String>();
 
	fruits.add("Pineapple");
	fruits.add("Apple");
	fruits.add("Orange");
	fruits.add("Banana");
 
	Collections.sort(fruits);
 
	int i=0;
	for(String temp: fruits){
		System.out.println("fruits " + ++i + " : " + temp);
	}

Output

fruits 1 : Apple
fruits 2 : Banana
fruits 3 : Orange
fruits 4 : Pineapple

3. Sort an Object with Comparable

How about a Java Object? Let create a Fruit class:

public class Fruit{
 
	private String fruitName;
	private String fruitDesc;
	private int quantity;
 
	public Fruit(String fruitName, String fruitDesc, int quantity) {
		super();
		this.fruitName = fruitName;
		this.fruitDesc = fruitDesc;
		this.quantity = quantity;
	}
 
	public String getFruitName() {
		return fruitName;
	}
	public void setFruitName(String fruitName) {
		this.fruitName = fruitName;
	}
	public String getFruitDesc() {
		return fruitDesc;
	}
	public void setFruitDesc(String fruitDesc) {
		this.fruitDesc = fruitDesc;
	}
	public int getQuantity() {
		return quantity;
	}
	public void setQuantity(int quantity) {
		this.quantity = quantity;
	}
}

To sort it, you may think of Arrays.sort() again, see below example :

package com.mkyong.common.action;
 
import java.util.Arrays;
 
public class SortFruitObject{
 
	public static void main(String args[]){
 
		Fruit[] fruits = new Fruit[4];
 
		Fruit pineappale = new Fruit("Pineapple", "Pineapple description",70); 
		Fruit apple = new Fruit("Apple", "Apple description",100); 
		Fruit orange = new Fruit("Orange", "Orange description",80); 
		Fruit banana = new Fruit("Banana", "Banana description",90); 
 
		fruits[0]=pineappale;
		fruits[1]=apple;
		fruits[2]=orange;
		fruits[3]=banana;
 
		Arrays.sort(fruits);
 
		int i=0;
		for(Fruit temp: fruits){
		   System.out.println("fruits " + ++i + " : " + temp.getFruitName() + 
			", Quantity : " + temp.getQuantity());
		}
 
	}	
}

Nice try, but, what you expect the Arrays.sort() will do? You didn’t even mention what to sort in the Fruit class. So, it will hits the following error :

Exception in thread "main" java.lang.ClassCastException: 
com.mkyong.common.Fruit cannot be cast to java.lang.Comparable
	at java.util.Arrays.mergeSort(Unknown Source)
	at java.util.Arrays.sort(Unknown Source)

To sort an Object by its property, you have to make the Object implement the Comparable interface and override thecompareTo() method. Lets see the new Fruit class again.

public class Fruit implements Comparable<Fruit>{
 
	private String fruitName;
	private String fruitDesc;
	private int quantity;
 
	public Fruit(String fruitName, String fruitDesc, int quantity) {
		super();
		this.fruitName = fruitName;
		this.fruitDesc = fruitDesc;
		this.quantity = quantity;
	}
 
	public String getFruitName() {
		return fruitName;
	}
	public void setFruitName(String fruitName) {
		this.fruitName = fruitName;
	}
	public String getFruitDesc() {
		return fruitDesc;
	}
	public void setFruitDesc(String fruitDesc) {
		this.fruitDesc = fruitDesc;
	}
	public int getQuantity() {
		return quantity;
	}
	public void setQuantity(int quantity) {
		this.quantity = quantity;
	}
 
	public int compareTo(Fruit compareFruit) {
 
		int compareQuantity = ((Fruit) compareFruit).getQuantity(); 
 
		//ascending order
		return this.quantity - compareQuantity;
 
		//descending order
		//return compareQuantity - this.quantity;
 
	}	
}

The new Fruit class implemented the Comparable interface, and overrided the compareTo() method to compare its quantity property in ascending order.

Run it again, now the Fruits array is sort by its quantity in ascending order.

fruits 1 : Pineapple, Quantity : 70
fruits 2 : Orange, Quantity : 80
fruits 3 : Banana, Quantity : 90
fruits 4 : Apple, Quantity : 100

4. Sort an Object with Comparator

How about sorting with Fruit’s “fruitName” or “Quantity”? The Comparable interface is only allow to sort a single property. To sort with multiple properties, you need Comparator. See the new updated Fruit class again :

import java.util.Comparator;
 
public class Fruit implements Comparable<Fruit>{
 
	private String fruitName;
	private String fruitDesc;
	private int quantity;
 
	public Fruit(String fruitName, String fruitDesc, int quantity) {
		super();
		this.fruitName = fruitName;
		this.fruitDesc = fruitDesc;
		this.quantity = quantity;
	}
 
	public String getFruitName() {
		return fruitName;
	}
	public void setFruitName(String fruitName) {
		this.fruitName = fruitName;
	}
	public String getFruitDesc() {
		return fruitDesc;
	}
	public void setFruitDesc(String fruitDesc) {
		this.fruitDesc = fruitDesc;
	}
	public int getQuantity() {
		return quantity;
	}
	public void setQuantity(int quantity) {
		this.quantity = quantity;
	}
 
	public int compareTo(Fruit compareFruit) {
 
		int compareQuantity = ((Fruit) compareFruit).getQuantity(); 
 
		//ascending order
		return this.quantity - compareQuantity;
 
		//descending order
		//return compareQuantity - this.quantity;
 
	}
 
	public static Comparator<Fruit> FruitNameComparator 
                          = new Comparator<Fruit>() {
 
	    public int compare(Fruit fruit1, Fruit fruit2) {
 
	      String fruitName1 = fruit1.getFruitName().toUpperCase();
	      String fruitName2 = fruit2.getFruitName().toUpperCase();
 
	      //ascending order
	      return fruitName1.compareTo(fruitName2);
 
	      //descending order
	      //return fruitName2.compareTo(fruitName1);
	    }
 
	};
}

The Fruit class contains a static FruitNameComparator method to compare the “fruitName”. Now the Fruit object is able to sort with either “quantity” or “fruitName” property. Run it again.

1. Sort Fruit array based on its “fruitName” property in ascending order.

Arrays.sort(fruits, Fruit.FruitNameComparator);

Output

fruits 1 : Apple, Quantity : 100
fruits 2 : Banana, Quantity : 90
fruits 3 : Orange, Quantity : 80
fruits 4 : Pineapple, Quantity : 70

2. Sort Fruit array based on its “quantity” property in ascending order.

Arrays.sort(fruits)

Output

fruits 1 : Pineapple, Quantity : 70
fruits 2 : Orange, Quantity : 80
fruits 3 : Banana, Quantity : 90
fruits 4 : Apple, Quantity : 100

My thoughts…

In future, Arrays class should provides more generic and handy method – Arrays.sort(Object, String, flag).

To sort a object array by its “fruitName” in ascending order.

Arrays.sort(fruits, fruitName, Arrays.ASCENDING);

To sort a object array by its “quantity” in ascending order.

Arrays.sort(fruits, quantity, Arrays.DESCENDING);

Reference

1. Comparable documentation
2. Comparator documentation