자바 디자인 패턴 두번째 포스팅
- 싱글톤 패턴이란 어떤 것인지
- 싱글톤 패턴은 어떤 상황에 쓰는 것인지
-싱글톤 패턴과 정적 클래스(Static)의 차이
0. 싱글톤 패턴(Singleton) 이란?
최초 한 번만 메모리를 할당하고
그 메모리에 인스턴스를 만들어 사용하는 디자인 패턴.
단 하나의 인스턴스를 생성해 사용하는 디자인 패턴이다.
인스턴스가 오직 하나만 생성되는 것을 보장하고 어디서든 이 인스턴스에 접근 가능한 패턴이다.
인스턴스가 필요할 때 똑같은 인스턴스를 만들어 내는 것이 아니라
기존의 동일한 인스턴스를 사용하게 한다.
다시말해 하나의 인스턴스만 만드는 책임이 있고,
인스턴스를 반환하는 행동을 통해 모든 클라리언트에게 동일한 작업을 보내는 것.
생성자가 여러차례 호출되더라도 실제로 생성되는 객체는 하나고,
최초 생성 이후에 호출된 생성자는 최초에 생성한 객체를 반환한다.
1. 싱글톤 패턴을 사용하는 이유
고정된 메모리 영역을 얻으면서 한번의 new로 인스턴스를 사용하기 때문에 메모리 낭비가 없다.
또 싱글톤으로 만들어진 클래스의 인스턴스는 전역 인스턴스기 때문에 다른 클래스의 인스턴스들이 데이터를 공유하기 쉽다.
따라서 공통된 객체를 여러개 생성해서 쓰는 상황에서 많이 사용한다!
예를 들어 작은 회사에서 쓰는 한 대의 프린터기, 대화상자나 로그 기록 객체 등.
인스턴스가 절대적으로 한개만 존재하는 것을 보증하고 싶을 경우 사용한다고 볼 수 있다.
2. 싱글톤 패턴의 문제점
싱글톤 인스턴스가 너무 많은 일을 하거나
많은 데이터를 공유시킬 경우에
다른 클래스 인스턴스 간에 결합도가 높아져 객체지향 설계 원칙에 어긋나는'개방-폐쇄' 원칙을 위배하게 된다.
따라서 수정이나 테스트하기가 어려워진다.
또 멀티쓰레드 환경에서 동기화 처리를 안하면 인스턴스가 두개 생성된다는 문제가 발생하기도 한다.
3. 싱글톤 패턴 예제
Printer
작은 회사에서 쓰는 한 대의 프린터기 를 구현한다고 생각해 보자.
이 프린터기의 조건은 (1)외부에서 임의로 생성할 수 없어야하며,
(2)접근할 수 있는 방법이 여러군데 가 되지 않아야 한다.
class Printer {
private static Printer printer = null;
private Printer() {
}
public static Printer getPrinter() {
if(printer == null)
{
printer printer;
}
public void print(Resource r) {
}
}
우선!
회사에 프린터기가 단 한 대 뿐이라..
한 대 뿐인 프린터기는 한번에 하나의 일만 처리할 수 있다.
= 이를 사용하는 클라이언트 프로그램에서
프린터 객체를 단 한번만 생성해야 한다.
어떻게 하면 프린터기 객체를 한 번만 생성할 수 있을까?
가장 간단하 방법으로는 생성자를 외부에서 호출하지 못하게 하는 방법이 있다.
프린터 클래스 생성자의 접근제어자를 private 으로 하는 것이다!_!
그러나 이렇게 하면 또 문제점이 발생한다.
어느 곳에서도 프린트 생성자에 접근할 수 없다는 것..
이는 프린터 자체를 생성할 수 없다는 의미이기도 하고,
이러면 클래스를 만드는 이유가 없다.
어떻게 해야할까?
3-a.
class Printer {
private static Printer printer = null;
private Printer() {
}
public static Printer getPrinter() {
if (printer == null) {
printer = new Printer();
}
return printer;
}
public void print(String srt) {
System.out.println(srt);
}
}
getPrinter 라는 메소드를 추가해 주었다.
이 getPrinter 메소드는 -
if 문으로 프린터 객체가 생성이 되어 있는지, 안되어 있는지 체크하는 기능을 수행한다.
프린터가 null이면, 생성이 안되어 있으면=
생성을 하고 반환을 해주고~~
한번 호출이 되었다면 반환을 해주는 루틴을 타게 된다.
이 경우,
static 으로 되어 있는 메소드에서 프린트 객체를 생성하고 반환해 주기 때문에 -
public static Printer getPrinter() {
if (printer == null) {
printer = new Printer();
프린터도 동일하게 static으로 구현해야 한다.
class Printer {
private static Printer printer = null;
private Printer() {}
여기서 집중해야 하는 부분은
이 static은, 정적 변수, 정적 메소드는
객체 영역이 아니라 클래스 자체에 속하게 된다는 것이다.
따라서 프린터 객체를 따로 선언하지 않아도
프린터 클래스의 특정 변수나 메서드로 사용할 수 있다는 것.
또 이는 해당 클래스로 생성된 프린터 객체를 다 같이 공유해서 사용할 수 있다.
물론 private이니 객체 자체를 공유하진 못하겠지만..
그래서 이 클래스만으로도 아까 고민 했던
(1) 외부에서 임의로 생성하지 못하게, 여러개의 자원으로 만들어지지 않게
= 생성자를 private으로 만들어 해결했고,
(2) 외부에서 사용하지 못하는 private 의 문제점을 해결하기 위해
이 객체를 사용할 수 있는 용도의 getPrinter 함수를 하나 열어주었고,
객체를 만들지 못하기 때문에 클래스에서 사용할 수 있는 클래스 메소드로 static으로 만들어 주었고,
그리고 그 안 실질적인 객체도 static으로 만들어서 반환해 주게 했고,
또 if문으로 다중으로 생성되지 않게도 했다.
그래서 위의 코드만 가지고도
위에서 했던 고민들을 해결한 것이다 👍🏻
이어서 이 프린터기를 사용할 유저에 대한 시뮬레이션 코드,
메인 함수도 만들어 보자.
class User {
private String name;
public User(String name) {
this.name = name;
}
public void print() {
Printer printer = Printer.getPrinter();
printer.print(this.name + "print using" + printer.toString() + ".");
}
}
이에 대한 결과 값은 아래와 같다.
그 런 데 ......
성공한 것만 같은 위 코드는
단일 스레일 경우 문제가 없지만-
다중 스레드 상황일 때 문제가 발생한다.
아래는 문제 상황의 시나리오이다.
1) Printer 인스턴스가 아직 생성되지 않았을 때
쓰레드 1이 getPrinter 메서드의 if문을 실행해
이미 인스턴스가 생성되었는지 확인한다. 현재 printer 변수는 null인 상태.
2) 만약 쓰레드 1이 생성자를 호출해 인스턴스를 만들기 전 쓰레드 2가 if문을 실행해 printer 변수가 null인지 확인한다.
현재 null이므로 인스턴스를 생성하는 코드,
즉 생성자를 호출하는 코드를 실행하게 된다. ->
3) 쓰레드 1도 쓰레드2와 마찬가지로 인스터스를 생성하는 코드를 실행하게 되면 결과적으로 Printer클래스의 인스턴스가 2개 생성된다.
싱글톤.다중 스레드 상황에서 문제점
즉, 독립적으로 동작하고 있는 스레드가
동일 코드에 접근하다가 우연히 둘 다 프린터기가 생성이 안된 상태에서,
동시에 프린터에 접근해 둘 다 프린터 객체를 생성한 상황인 것이다.
이러면 경합 이라는 조건을 발생 시키고 만다.
이 문제를 고쳐 보도록 하자.
3 - b . 다중 스레드
싱글톤 패턴
아래의 코드는,
일부러 다중 스레드가 동작하게끔 살짝 수정한 코드이다.
sleep(1), 1 millis 정도 짧은 시간의 딜레이를 부여해서 경합하는 상황을 유도해 보았다.
물론 이 부분이 없어도 잘 나오지만
경합 상황의 확률을 조금이라도 더 높혀보고자..
3-b.
class Printer {
private static Printer printer = null;
private Printer() {
}
public static Printer getPrinter() {
if (printer == null) {
try {
Thread.sleep(1);
printer = new Printer();
} catch (InterruptedException t) {
}
}
return printer;
}
public void print(String srt) {
System.out.println(srt);
}
}
class User extends Thread {
private String name;
public User(String name) {
this.name = name;
}
public void run() {
Printer printer = Printer.getPrinter();
printer.print(this.name + " print using " + printer.toString() + ".");
}
}
꽤 바뀐 부분은 User 인데,
스레드를 상속 받고
class User extends Thread {
run 이라는 함수에서
public void run() {
Printer printer = Printer.getPrinter();
프린터기를 받아오고,
아래 출력 하는 것 까지 구현했다.
printer.print(this.name + " print using " + printer.toString() + ".");
이 run이라고 하는 코드를 통해
유저가 스레드로 생성이 되고,
단일 각각의 동작을 하게 되는 것이다.
그리고 실제 돌아가는 메인 함수는-
public class SingClient {
private static final int User_NUM = 5;
public static void main(String[] arg) {
User[] user = new User[User_NUM];
for (int i = 0; i < User_NUM; i++)
{
user[i] = new User((i + 1) + "-user");
*이부분-> user[i].start();
}
아까 print로 했던 저 부분만 start라고 수정해서
각각의 프로세스가 비동기(순차X)로 실행되게 했다.
아래는 결과값이다.
결과를 보니... 일단 1 3 4 2 5 비동기로 잘 나왔고,
중요한 것은 저 뒷부분 id 프린터 객체가
아까는 값이 똑같았는데,
지금은 프로세스에서 각각의 것을 생성해서 각각 다른 객체가 된 것이다.
싱글톤 패턴은 하나의 객체를 만들어서 공유하는 것인데..
우리 싱글톤 패턴이 추구하는 것과는 전혀 다른 결과가 나왔다.
이를 통해 방금 수정한 코드는 싱글톤 패턴이긴 하지만,
다중 쓰레드에서 이런 문제를 일으킨다는 것을 확인했다.
3-c. 다중 스레드 문제
그럼 프린터 클래스가 상태를 유지하는 경우 문제를 해결해 보자.
3-c.
class Printer {
private static Printer printer = null;
private int count = 0;
private Printer() {
}
public static Printer getPrinter() {
if (printer == null) {
try {
Thread.sleep(1);
printer = new Printer();
} catch (InterruptedException t)
{
}
}
return printer;
}
public void print(String srt) {
count++;
System.out.println(srt+count);
}
}
카운트 라는 변수를 추가해서
그리고 실제 프린트가 될 때마다 카운트를 증가시켜주고,
그것을 출력하게 코드를 수정했다.
이에 대한 카운트 결과값이 모두 1로 동일하다.
동일한 객체를 이용한다고 했으니 불려질 때마다 카운트가 올라가니 올라가야 할 텐데,
이건 어떻게 고쳐줘야할까?
방법 1.
정적 변수에 인스턴스를 만들어 바로 초기화 :
3-d.
class Printer {
private static Printer printer = new Printer();
private int count = 0;
private Printer() {
}
public static Printer getPrinter() {
return printer;
}
public void print(String srt) {
count++;
System.out.println(srt + count);
}
}
프린터 클래스가 메모리가 올라갈 때,
그 때 new Printer(); 로 생성해서 올려 버리는 것!
그 이후엔 프린터를 생성하는 코드가 없다.
출력시켜 보자.
아이디가 같다!
그럼 일단 하나의 객체를 가지고 공유해서 사용했으니,
싱글톤 패턴으로는 만들어 진 것이라 할 수 있겠다.
근데... 공유되는 데이터는 어떤가요?
공유되는 데이터는 그렇지 않은 상황.
공유되는 데이터에 대한 접근이 경합을 일으키게 되어있다.ㅠㅠ
한번만 접근할 수 있는게 아니라
다른게 처리되기 전에 먼저 접근해서 바꿔 버린 상황이다.
방법 2.
인스턴스를 만드는 메서드에 동기화 하는 방법.
3-e.
class Printer {
private static Printer printer = null;
private int count = 0;
private Printer() {
}
public static synchronized Printer getPrinter() {
if (printer == null) {
try {
Thread.sleep(1);
printer = new Printer();
} catch (InterruptedException e) {
}
}
return printer;
}
프린터 클래스의 객체를 얻을 수 있는 get Printer 메서드를 동기화 시키는 것이다.
순차적으로 접근하게끔!
여기에서는 해당 메서드에 synchronized를 추가해서,
다중 쓰레드로 접근하는 것은 한 번에 하나씩, 차례대로(동기화) 들어오게 한다.
'지금 누가 접근하고 있으니, 잠시 기다려' (이렇게 하나하나 기다리게)
그래서 이 synchronized는
다중 스레드 환경에서 동시에 여러개가 메소드에 접근하는 것을 방지하고
스케쥴링 해주는 것 이라 생각하면 되겠다.
결과를 살펴보면,
비동기로 접근을 하지만 실제로 만들어진 프린터 객체는 다 동일하다.(id값 동일)
한번만 생성이 된 것이다.
마지막 결과 값도 보면..
카운터에 대한 접근이 비동기로 이루어 지고 있기 때문에 결과 값이 제각각이다.
그럼 아직도 카운트 객체에 대해 비동기로 접근하고
경합이 이루어지고 있는 상황을 해결해 보자.
3 - f. 카운트 문제 해결
문제를 해결하기 위해선,
프린트 메서드에서 제공하고 있는 카운트를 바꾸는 부분인
count++;
이 부분에도 동기화 코드를 넣어 줘야할 필요가 있다.
3-f.
public void print(String srt) {
여기** synchronized (this) {
count++;
System.out.println(srt + count);
}
}
}
이렇게 수정을 하면, 프린트에 접근해서 카운트를 변경하는 이 부분에-
순차적으로 들어오게끔 한다.
결과를 보면
비동기로 만들어 졌지만 실제로 프린트가 될 때는,
1 2 3 4 5 요렇게 순차적으로 표현이 되는 것이다.
결국 !
다중 스레드에서 뭔가 처리할 때는
스레드가 접근할 때, 비동기 적인 스레드를
동기화 시켜서 접근하게 해주는 synchronized를 이용하거나
싱글톤 패턴을 만들 때는 선언과 동시에 객체를 생성 하거나!
그러면 싱글톤 패턴에서 하나의 객체를 사용해야 한다는 조건은 만족하는 코드가 만들어 진 것이다.
4. 싱글톤 패턴 정리
싱글톤 패턴의 특징
예제를 통해 살펴본 싱글톤 패턴의 특징들을 정리해 보자.
|
Singleton |
|
- instance : private 인스턴스 하나 |
|
- Singleton() : 생성자가 private으로 되어있다. (다른 곳애서 못쓰게) + getinstance() : 인스턴스를 반환해줌. |
1) 어플리케이션이 시작될 때 어떤 클래스가 한번만 메모리를 할당하고,
그 메모리에 인스턴스를 만들어 사용하는 디자인 패턴.
2) 생성자가 여러번 호출 되어도 실제로 일어나는 객체는 하나고,
최초 생성 이후 호출된 생성자는 최초에 생긴 객체를 반환.
3) 단 하나의 인스턴스를 생성해 사용하는 패턴.(기존의 동일한 인스턴스)
|
장점 |
단점 / 문제점 |
|
고정된 메모리 영역을 얻으면서 한번의new로 인스턴스를 사용하기 때문에 메모리 낭비를 줄일 수 있다. |
싱글톤 인스턴스가 너무 많은 일을 하거나 많은 데이터를 공유시킬 경우 다른 클래스의 인스턴스들 간에 결합도가 높아져 '개방 폐쇄 원칙'에 위배된다. 수정과 테스트가 어려워짐. |
|
싱글톤 클래스의 인스턴스는 전역 인스턴스이기 때문에 다른 클래스의 인스턴스들이 데이터를 공유하기 쉽다. |
동기화 처리(synchronized)를 하지 않으면 인스턴스가 두개가 생성되는 일이 생길수 있다.(주의) |
|
공통된 객체를 여러개 생성해 사용할 때 좋다. (쓰레드풀, 캐시, 로그 기록 객체 등) | |
|
인스턴스가 절대적으로 한개만 존재하는 것을 보증하고 싶을 때 사용 |
|
Client -> 인스턴스 요청 -> Singleton |
Singleton - 인스턴스 있을 시 : 반환 - 인스턴스 없을 시 : 생성 후 반환 |
Client <- 인스턴스 반환 <- Singleton |
5. 싱글톤 패턴과 Static(정적 클래스)
드디어
그런데 정적 클래스를 사용해도 싱글톤 패턴과 동일한 효과를 얻을 수 있다!?
아래는 싱글톤을 사용하지 않고 정적 메소드로만 구현한 정적 클래스이다.
class Printer0504 {
private static int count = 0;
private Printer0504() {
}
public synchronized static void print(String str) {
count++;
System.out.println(str + count);
}
}
class User extends Thread {
private String name;
public User(String name) {
this.name = name;
}
public void run() {
Printer0504.print(this.name + "print using" + ".");
}
}
public class Client0504 {
private static final int User_NUM = 5;
public static void main(String[] args) {
User[] user = new User[User_NUM];
for (int i = 0; i < User_NUM; i++) {
user[i] = new User((i + 1) + "-user");
user[i].start();
}
}
}
출력해보면 이렇게 싱글톤과 동일한 효과를 얻을 수 있다는 것을 알 수 있다.
오히려 싱글톤 패턴에서 런타임 시에 바인딩이 되는 인스턴스 보다,
정적 메서드가(static) 성능이 더 우수하기도 하다.
그렇다면 정적 메서드가 더 좋은걸까? 싶기도 하지만,
이 정적메소드를 사용할 수 없는 경우가 있다.
바로 Interface를 사용할 때.
정적 메서드로는 Interface를 구현(오버라이드)할 수 없기 때문에, 인터페이스가 필요하면 싱글톤으로 구현해야 한다.
정적메소드(static)과 싱글톤(Singleton)의 차이에 대해 조금 더 자세히 알아보자.
6. Singleton과 Static의 차이
|
차이 |
Singleton |
Static class |
|
원리 |
사용자 요청시 하나의 인스턴스를 생성해 재사용 |
인스턴스를 만들 수 없고 생성자도 X |
|
인터페이스 구현 |
가능 |
불가능 |
|
Override |
가능 |
불가능 |
|
저장위치 |
Heap |
메서드 영역(클래스 영역) |
1) 멀티스레드에서는 둘 다 하나를 공유한다.
한 VM에 100개의 쓰레드가 생성되었다고 할 때
static 오브젝트는 그 VM에 단 하나만 생성되고 모든 쓰레드가 공유한다.
싱글톤도 마찬가지로 JVM(클래스 로더)마다 인스턴스가 하나만 만들어지고 모든 쓰레드가 공유한다. 쓰레드마다 따로 쓰는 객체가 필요하다면 싱글톤이 아니라 ThreadLocal을 써야 한다.
2) Static 클래스는 인터페이스 구현 및 클래스 상속이 안된다. (싱글톤은 가능하다.)
참고: