디자인 모드 2: 단일 예

디자인 모드 2: 단일 예
1. 정의
단일 예 (Singleton) 모드 의 정의: 하나의 인 스 턴 스 만 있 고 이 인 스 턴 스 를 자체 적 으로 만 들 수 있 는 모델 을 말 합 니 다.
2. 단일 모델 의 장점 과 단점
단일 모드 의 장점:

단일 모드 는 메모리 에 하나의 인 스 턴 스 만 있 고 메모리 비용 을 줄 일 수 있 습 니 다.

자원 에 대한 다 중 점용 을 피 할 수 있다.

단일 모델 은 전체 방문 점 을 설정 하여 자원 의 방문 을 최적화 하고 공유 할 수 있다.

단일 모드 의 단점:

단일 모드 는 일반적으로 인터페이스 가 없고 확장 이 어렵다.확장 하려 면 원래 코드 를 수정 하 는 것 외 에 두 번 째 경로 가 없고 개폐 원칙 에 위배 된다.

동시 테스트 에서 단일 모델 은 코드 디 버 깅 에 불리 하 다.디 버 깅 과정 에서 단일 사례 의 코드 가 실행 되 지 않 으 면 새로운 대상 을 만 드 는 것 을 모 의 할 수 없습니다.

단일 모델 의 기능 코드 는 보통 한 가지 유형 에 쓰 이 는데 기능 디자인 이 합 리 적 이지 않 으 면 단일 직책 원칙 에 어 긋 나 기 쉽다.

3. 실현 방식
단일 모드 는 8 가지 방식 이 있 습 니 다.

1) 굶 주 린 식 (정적 상수)

2) 굶 주 린 식 (정적 코드 블록)

3) 게으름뱅이 식 (스 레 드 가 안전 하지 않 음)

4) 게으름뱅이 식 (스 레 드 안전, 동기 화 방법)

5) 게으름뱅이 식 (스 레 드 안전, 동기 코드 블록)

6) 이중 검사

7) 정적 내부 클래스

8) 매 거 진

3.1 굶 주 림 식 (정적 상수)

/**
 *  、   (    )
 *   ：            。         ；
 *   ：     Lazy Loading    
 */
public class Singleton1 {

    // 2.          
    private final static Singleton1 instance = new Singleton1();

    // 1.      
    private Singleton1(){
    }

    // 3.           ，      
    public Singleton1 getInstance(){
        return instance;
    }
}

3.2 굶 주 린 사람 식 (정적 코드 블록)

/**
 *  、   (     )
 *   ：            。         ；
 *   ：     Lazy Loading    
 */
public class Singleton2 {

    // 1.      
    private Singleton2(){
    }

    // 2.      
    private final static Singleton2 instance;

    //3.       ，      
    static { 
        instance = new Singleton2();
    }

    // 4.           ，      
    public Singleton2 getInstance(){
        return instance;
    }
}

3.3 게으름뱅이 식 (라인 이 안전 하지 않 음)

/**
 *  、   (     )
 *   ：    Lazy Loading    ；
 *   ：       ，        if (singleton == null)     ，         ，
 *                ，          。                 
 */
public class Singleton3 {

    // 1.      
    private Singleton3() {
    }

    // 2.      
    private static Singleton3 instance;

    //3.           ，        ，     instance
    public static Singleton3 getInstance() {
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }
}

3.4 게으름뱅이 식 (스 레 드 안전, 동기 화 방법)

/**
 * 4    (    ，    )
 *   ：         ；
 *   ：     ，              ，   getInstance()        
 */
public class Singleton4 {

    // 1.      
    private Singleton4() {
    }

    // 2.      
    private static Singleton4 instance;

    // 3.           ，        ，     instance
    // 4.         ，        
    public static synchronized Singleton4 getInstance() {
        if (instance == null) {
            instance = new Singleton4();
        }
        return instance;
    }
}

3.5 게으름뱅이 식 (스 레 드 안전, 동기 코드 블록)

/**
 * 5    (    ，     )
 *   ：         ；
 *   ：     ，              ，   getInstance()        
 */
public class Singleton5 {

    // 1.      
    private Singleton5() {
    }

    // 2.      
    private static Singleton5 instance;

    // 3.           ，        ，     instance
    // 4.         ，        ,       
    public static Singleton5 getInstance() {
        if (instance == null) {
            synchronized (Singleton5.class) {
                instance = new Singleton5();
            }
        }
        return instance;
    }
}

3.6 이중 검사

/**
 * 6     
 *   ：    ；    ；    ；
 *   ：#
 *     
 */
public class Singleton6 {

    // 1.      
    private Singleton6() {
    }

    // 2.       volatile
    private static volatile  Singleton6 instance;

    // 3.           ，        ，        ,          
    // 4.         ，        
    public static Singleton6 getInstance() {
        if (instance == null) {
            synchronized (Singleton6.class) {
                if(instance == null){
                    instance = new Singleton6();
                }
            }
        }
        return instance;
    }
}

3.7 정적 내부 클래스

/**
 * 7      
 *   ：                        ；
 *   ：#
 *     
 */
public class Singleton7 {

    // 1.      
    private Singleton7() {
    }

    // 2.      
    private static  Singleton7 instance;

    // 3.         ,          
     private static class SingletonInstance {
        private static final Singleton7 INSTANCE = new Singleton7();
    }

    // 4.           ，     SingletonInstance.INSTANCE
    public static  Singleton7 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

3.8 매 거

/**
 * 8   
 *   ：    JDK1.5              。            ，                  ；
 *   ：#
 *       Effective Java    Josh Bloch       
 */
public enum Singleton8 {
    INSTANCE; //  

    public void sayOK() {
        System.out.println("ok~");
    }
}

public class Singleton8Test {
    public static void main(String[] args) {
         Singleton8 instance = Singleton8.INSTANCE;
         Singleton8 instance2 = Singleton8.INSTANCE;
        instance.sayOK();
        instance2.sayOK();
        System.out.println(instance == instance2);
    }
}

4. 단일 모드 응용 장면

자주 만들어 야 하 는 클래스 입 니 다. 단일 예 를 사용 하면 시스템 의 메모리 압력 을 낮 추고 GC 를 줄 일 수 있 습 니 다.

특정한 유형 이 하나의 대상 만 생 성 하 라 고 요구 할 때.

일부 클래스 는 인 스 턴 스 를 만 들 때 자원 을 많이 차지 하거나 예화 시간 이 오래 걸 리 며 자주 사용 합 니 다.

특정한 종 류 는 빈번 한 예화 가 필요 하고 만 든 대상 이 자주 소각 되 었 을 때, 예 를 들 어 다 중 스 레 드 탱크, 네트워크 연결 탱크 등 이다.

데이터베이스 나 파일 에 자주 접근 하 는 대상.

일부 하드웨어 등급 을 제어 하 는 조작 이나 시스템 으로 볼 때 단일 제어 논리 적 인 조작 이 어야 한다. 만약 에 여러 개의 사례 가 있 으 면 시스템 이 완전히 혼 란 스 러 울 것 이다.

대상 이 공유 되 어야 하 는 장소.단일 모드 에 서 는 하나의 대상 만 만 만 들 수 있 기 때문에 이 대상 을 공유 하면 메모 리 를 절약 하고 대상 의 접근 속 도 를 가속 화 할 수 있 습 니 다.웹 의 설정 대상, 데이터베이스 연결 풀 등.