[java] Java에서 싱글 톤 패턴을 구현하는 효율적인 방법은 무엇입니까? [닫은]

면책 조항 : 나는 모든 훌륭한 답변을 요약하고 내 말로 썼습니다.

Singleton을 구현하는 동안 우리는 두 가지 옵션이 있습니다
. 1. Lazy loading
2. Early loading

게으른 로딩은 비트 오버 헤드 (많은 솔직함)를 추가하므로 매우 큰 객체 또는 무거운 구성 코드가 있고 인스턴스가 필요하기 전에 사용할 수있는 다른 액세스 가능한 정적 메소드 또는 필드가있는 경우에만 사용하십시오 초기 로딩을 선택하는 것이 좋습니다.

싱글 톤을 구현하는 가장 간단한 방법은

public class Foo {

    // It will be our sole hero
    private static final Foo INSTANCE = new Foo();

    private Foo() {
        if (INSTANCE != null) {
            // SHOUT
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return INSTANCE;
    }
}

초기로드 된 싱글 톤을 제외한 모든 것이 좋습니다. 게으른로드 된 싱글 톤을 시도 할 수 있습니다

class Foo {

    // Our now_null_but_going_to_be sole hero 
    private static Foo INSTANCE = null;

    private Foo() {
        if (INSTANCE != null) {
            // SHOUT  
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        // Creating only  when required.
        if (INSTANCE == null) {
            INSTANCE = new Foo();
        }
        return INSTANCE;
    }
}

지금까지는 좋지만 우리의 영웅은 많은 영웅을 원하는 여러 악의 실과 혼자 싸우면서 생존하지 못합니다. 사악한 멀티 스레딩으로부터 보호하십시오.

class Foo {

    private static Foo INSTANCE = null;

    // TODO Add private shouting constructor

    public static Foo getInstance() {
        // No more tension of threads
        synchronized (Foo.class) {
            if (INSTANCE == null) {
                INSTANCE = new Foo();
            }
        }
        return INSTANCE;
    }
}

그러나 영웅을 보호하기에는 충분하지 않습니다. 영웅을 돕기 위해 할 수있는 최선의 방법

class Foo {

    // Pay attention to volatile
    private static volatile Foo INSTANCE = null;

    // TODO Add private shouting constructor

    public static Foo getInstance() {
        if (INSTANCE == null) { // Check 1
            synchronized (Foo.class) {
                if (INSTANCE == null) { // Check 2
                    INSTANCE = new Foo();
                }
            }
        }
        return INSTANCE;
    }
}

이것을 “이중 확인 잠금 관용구”라고합니다. 변덕스러운 진술을 잊기 쉽고 그것이 왜 필요한지 이해하기 어렵다.
자세한 내용은 http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

이제 우리는 사악한 스레드에 대해 확신하지만 잔인한 직렬화는 어떻습니까? de-serialization이 새 개체를 만들지 않아도 확인해야합니다.

class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    private static volatile Foo INSTANCE = null;

    // Rest of the things are same as above

    // No more fear of serialization
    @SuppressWarnings("unused")
    private Object readResolve() {
        return INSTANCE;
    }
}

이 메소드 readResolve()는 객체가 이전 프로그램 실행에서 직렬화 된 경우에도 유일한 인스턴스가 반환되도록합니다.

마지막으로 스레드와 직렬화에 대한 충분한 보호 기능을 추가했지만 코드가 거대하고보기 흉해 보입니다. 우리의 영웅에게 화장을 줄 수 있습니다

public final class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    // Wrapped in a inner static class so that loaded only when required
    private static class FooLoader {

        // And no more fear of threads
        private static final Foo INSTANCE = new Foo();
    }

    // TODO add private shouting construcor

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }

    // Damn you serialization
    @SuppressWarnings("unused")
    private Foo readResolve() {
        return FooLoader.INSTANCE;
    }
}

예이 바로 우리 같은 영웅입니다 🙂
라인이 있기 때문에 private static final Foo INSTANCE = new Foo();클래스가 경우에만 실행됩니다 FooLoader실제로 사용이 게으른 인스턴스를 돌봐,

스레드 안전성을 보장합니다.

그리고 우리는 지금까지 왔으며, 우리가 한 모든 것을 성취하는 가장 좋은 방법은 최선의 방법입니다

 public enum Foo {
       INSTANCE;
   }

내부적으로 어떤 것이 취급 될 것인가

public class Foo {

    // It will be our sole hero
    private static final Foo INSTANCE = new Foo();
}

그게 다야! 더 이상 직렬화, 스레드 및 못생긴 코드에 대한 두려움이 없습니다. 또한 ENUMS 싱글 톤은 느리게 초기화 됩니다.

이 방법은보다 간결하고 직렬화 기계를 무료로 제공하며 정교한 직렬화 또는 리플렉션 공격에도 불구하고 다중 인스턴스화에 대한 확실한 보장을 제공한다는 점을 제외하고는 공공 현장 접근 방식과 기능적으로 동일합니다. 이 방법은 아직 널리 채택되지 않았지만 단일 요소 열거 형 유형이 단일 톤을 구현하는 가장 좋은 방법입니다.

“유효한 자바”의 여호수아 블로흐

이제 왜 ENUMS가 Singleton을 구현하는 가장 좋은 방법으로 여겨지고 인내심을 가져 주셔서 감사합니다 🙂
내 블로그 에서 업데이트했습니다 .

답변

class Bar {
    private static class BarHolder {
        public static Bar bar = new Bar();
    }

    public static Bar getBar() {
        return BarHolder.bar;
    }
}

class Foo {
    private static volatile Bar bar = null;
    public static Bar getBar() {
        if (bar == null) {
            synchronized(Foo.class) {
                if (bar == null)
                    bar = new Bar();
            }
        }
        return bar;
    }
}

public class A {

    private static final A INSTANCE = new A();

    private A() {}

    public static A getInstance() {
        return INSTANCE;
    }
}