Java에서 인수가있는 싱글 톤

나는 Wikipedia에서 Singleton 기사를 읽고 있었고이 예제를 보았습니다.

public class Singleton {
    // Private constructor prevents instantiation from other classes
    private Singleton() {}

    /**
     * SingletonHolder is loaded on the first execution of Singleton.getInstance() 
     * or the first access to SingletonHolder.INSTANCE, not before.
     */
    private static class SingletonHolder { 
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

이 싱글 톤의 동작 방식이 정말 마음에 들지만, 생성자에 인수를 통합하도록 조정하는 방법을 볼 수 없습니다. Java에서이를 수행하는 선호되는 방법은 무엇입니까? 이런 식으로해야합니까?

public class Singleton
{
    private static Singleton singleton = null;  
    private final int x;

    private Singleton(int x) {
        this.x = x;
    }

    public synchronized static Singleton getInstance(int x) {
        if(singleton == null) singleton = new Singleton(x);
        return singleton;
    }
}

감사!

편집 : 나는 Singleton을 사용하려는 열망으로 논쟁의 폭풍을 시작했다고 생각합니다. 내 동기 부여를 설명하고 누군가가 더 나은 아이디어를 제안 할 수 있기를 바랍니다. 그리드 컴퓨팅 프레임 워크를 사용하여 작업을 병렬로 실행하고 있습니다. 일반적으로 다음과 같은 것이 있습니다.

// AbstractTask implements Serializable
public class Task extends AbstractTask
{
    private final ReferenceToReallyBigObject object;

    public Task(ReferenceToReallyBigObject object)
    {
        this.object = object;
    }

    public void run()
    {
        // Do some stuff with the object (which is immutable).
    }
}

결과는 데이터에 대한 참조를 모든 작업에 전달하더라도 작업이 직렬화되면 데이터가 계속 복사되는 것입니다. 내가하고 싶은 일은 모든 작업에서 객체를 공유하는 것입니다. 당연히 클래스를 다음과 같이 수정할 수 있습니다.

// AbstractTask implements Serializable
public class Task extends AbstractTask
{
    private static ReferenceToReallyBigObject object = null;

    private final String filePath;

    public Task(String filePath)
    {
        this.filePath = filePath;
    }

    public void run()
    {
        synchronized(this)
        {
            if(object == null)
            {
                ObjectReader reader = new ObjectReader(filePath);
                object = reader.read();
            }
        }

        // Do some stuff with the object (which is immutable).
    }
}

보시다시피, 여기에서도 다른 파일 경로를 전달하면 첫 번째 경로가 전달 된 후에 아무것도 의미가 없다는 문제가 있습니다. 이것이 내가 아이디어를 좋아하는 이유입니다. 답변에 게시 된 상점에 입니다. 어쨌든 run 메소드에 파일을로드하는 논리를 포함시키는 대신이 논리를 Singleton 클래스로 추상화하고 싶었습니다. 나는 또 다른 예를 제공하지는 않지만 아이디어를 얻길 바랍니다. 내가하려는 일을 더 우아하게 수행 할 수있는 방법에 대한 귀하의 아이디어를 들려주세요. 다시 감사합니다!

내 요점을 매우 명확하게 설명하겠습니다 . 매개 변수가있는 싱글 톤은 싱글 톤이 아닙니다 .

정의에 따르면 싱글 톤은 한 번만 인스턴스화하려는 객체입니다. 생성자에 매개 변수를 공급하려는 경우 싱글 톤의 요점은 무엇입니까?

두 가지 옵션이 있습니다. 단일 데이터를 일부 데이터로 초기화하려면 인스턴스화 후 다음 과 같이 데이터로로드 할 수 있습니다 .

SingletonObj singleton = SingletonObj.getInstance();
singleton.init(paramA, paramB); // init the object with data

싱글 톤이 수행하는 작업이 반복되고 매번 다른 매개 변수를 사용하는 경우 실행중인 기본 메소드에 매개 변수를 전달할 수도 있습니다.

SingletonObj singleton = SingletonObj.getInstance();
singleton.doSomething(paramA, paramB); // pass parameters on execution

어쨌든 인스턴스화는 항상 매개 변수가 없습니다. 그렇지 않으면 싱글 톤이 싱글 톤이 아닙니다.

다양한 매개 변수가있는 객체를 인스턴스화하고 재사용하려면 팩토리 와 같은 것이 필요하다고 생각합니다 . 동기화를 사용하여 구현 HashMap하거나 ConcurrentHashMap매개 변수 ( Integer예를 들어)를 'singleton'매개 변수화 가능 클래스에 매핑 하여 구현할 수 있습니다 .

대신 싱글 톤이 아닌 일반 클래스를 사용해야하는 시점에 도달 할 수 있습니다 (예 : 10.000 개의 다르게 매개 변수화 된 싱글 톤이 필요함).

이러한 상점의 예는 다음과 같습니다.

public final class UsefulObjFactory {

    private static Map<Integer, UsefulObj> store =
        new HashMap<Integer, UsefulObj>();

    public static final class UsefulObj {
        private UsefulObj(int parameter) {
            // init
        }
        public void someUsefulMethod() {
            // some useful operation
        }
    }

    public static UsefulObj get(int parameter) {
        synchronized (store) {
            UsefulObj result = store.get(parameter);
            if (result == null) {
                result = new UsefulObj(parameter);
                store.put(parameter, result);
            }
            return result;
        }
    }
}

더 나아가서, enum고정 수의 정적 변형 만 허용하더라도 Java 는 매개 변수가있는 싱글 톤으로 간주되거나 사용 될 수 있습니다.

그러나 분산 ¹ 솔루션 이 필요한 경우 측면 캐싱 솔루션을 고려하십시오. 예 : EHCache, Terracotta 등

¹ 아마 여러 대의 컴퓨터에 여러 개의 VM을 스패닝 의미한다.

인스턴스화와 가져 오기를 분리하기 위해 구성 가능한 초기화 방법을 추가 할 수 있습니다.

public class Singleton {
    private static Singleton singleton = null;
    private final int x;

    private Singleton(int x) {
        this.x = x;
    }

    public static Singleton getInstance() {
        if(singleton == null) {
            throw new AssertionError("You have to call init first");
        }

        return singleton;
    }

    public synchronized static Singleton init(int x) {
        if (singleton != null)
        {
            // in my opinion this is optional, but for the purists it ensures
            // that you only ever get the same instance when you call getInstance
            throw new AssertionError("You already initialized me");
        }

        singleton = new Singleton(x);
        return singleton;
    }

}

그런 다음 Singleton.init(123)앱 시작과 같이 한 번만 호출 하여 구성 할 수 있습니다 .

일부 매개 변수가 필수임을 표시하려는 경우 빌더 패턴을 사용할 수도 있습니다.

    public enum EnumSingleton {

    INSTANCE;

    private String name; // Mandatory
    private Double age = null; // Not Mandatory

    private void build(SingletonBuilder builder) {
        this.name = builder.name;
        this.age = builder.age;
    }

    // Static getter
    public static EnumSingleton getSingleton() {
        return INSTANCE;
    }

    public void print() {
        System.out.println("Name "+name + ", age: "+age);
    }


    public static class SingletonBuilder {

        private final String name; // Mandatory
        private Double age = null; // Not Mandatory

        private SingletonBuilder(){
          name = null;
        }

        SingletonBuilder(String name) {
            this.name = name;
        }

        public SingletonBuilder age(double age) {
            this.age = age;
            return this;
        }

        public void build(){
            EnumSingleton.INSTANCE.build(this);
        }

    }


}

그런 다음 다음과 같이 생성 / 인스턴스화 / 매개 변수화 할 수 있습니다 .

public static void main(String[] args) {
    new EnumSingleton.SingletonBuilder("nico").age(41).build();
    EnumSingleton.getSingleton().print();
}

" 매개 변수가있는 싱글 톤은 싱글 톤 이 아닙니다 "문이 완전히 올바르지 않습니다 . 코드 관점이 아닌 응용 프로그램 관점에서이를 분석해야합니다.

단일 응용 프로그램 실행에서 단일 객체 클래스를 만들기 위해 단일 클래스를 빌드합니다. 매개 변수가있는 생성자를 사용하면 코드를 유연하게 만들어 응용 프로그램을 실행할 때마다 싱글 톤 객체의 일부 속성을 변경할 수 있습니다. 이것은 싱글 톤 패턴을 위반하지 않습니다. 코드 관점에서 볼 때 위반으로 보입니다.

디자인 패턴은 유연하고 확장 가능한 코드를 작성하는 데 도움이되고 좋은 코드를 작성하는 데 방해가되지 않습니다.

getter 및 setter를 사용하여 변수를 설정하고 기본 생성자를 비공개로 설정하십시오. 그런 다음 사용하십시오.

Singleton.getInstance().setX(value);

로거 작성 / 검색 방법을 언급 한 사람이 아무도 없습니다. 예를 들어, 아래는 Log4J 로거 를 검색 하는 방법을 보여줍니다 .

// Retrieve a logger named according to the value of the name parameter. If the named logger already exists, then the existing instance will be returned. Otherwise, a new instance is created.
public static Logger getLogger(String name)

이 indirections의 몇 가지 수준이있다, 그러나 중요한 부분은 아래 방법을 거의 작동 방법에 대한 모든 것을 알려줍니다. 해시 테이블을 사용하여 종료 로거를 저장하고 키는 이름에서 파생됩니다. 이름으로 로거가 존재하지 않으면 팩토리를 사용하여 로거를 작성한 다음 해시 테이블에 추가합니다.

69   Hashtable ht;
...
258  public
259  Logger getLogger(String name, LoggerFactory factory) {
260    //System.out.println("getInstance("+name+") called.");
261    CategoryKey key = new CategoryKey(name);
262    // Synchronize to prevent write conflicts. Read conflicts (in
263    // getChainedLevel method) are possible only if variable
264    // assignments are non-atomic.
265    Logger logger;
266
267    synchronized(ht) {
268      Object o = ht.get(key);
269      if(o == null) {
270        logger = factory.makeNewLoggerInstance(name);
271        logger.setHierarchy(this);
272        ht.put(key, logger);
273        updateParents(logger);
274        return logger;
275      } else if(o instanceof Logger) {
276        return (Logger) o;
277      } 
...

Bill Pugh의 주문형 홀더 이디엄 초기화 를 사용하는 싱글 톤 패턴 수정 . 이것은 특수 언어 구조 (예 : 휘발성 또는 동기화)의 오버 헤드없이 스레드 안전합니다.

public final class RInterfaceHL {

    /**
     * Private constructor prevents instantiation from other classes.
     */
    private RInterfaceHL() { }

    /**
     * R REPL (read-evaluate-parse loop) handler.
     */
    private static RMainLoopCallbacks rloopHandler = null;

    /**
     * SingletonHolder is loaded, and the static initializer executed, 
     * on the first execution of Singleton.getInstance() or the first 
     * access to SingletonHolder.INSTANCE, not before.
     */
    private static final class SingletonHolder {

        /**
         * Singleton instance, with static initializer.
         */
        private static final RInterfaceHL INSTANCE = initRInterfaceHL();

        /**
         * Initialize RInterfaceHL singleton instance using rLoopHandler from
         * outer class.
         * 
         * @return RInterfaceHL instance
         */
        private static RInterfaceHL initRInterfaceHL() {
            try {
                return new RInterfaceHL(rloopHandler);
            } catch (REngineException e) {
                // a static initializer cannot throw exceptions
                // but it can throw an ExceptionInInitializerError
                throw new ExceptionInInitializerError(e);
            }
        }

        /**
         * Prevent instantiation.
         */
        private SingletonHolder() {
        }

        /**
         * Get singleton RInterfaceHL.
         * 
         * @return RInterfaceHL singleton.
         */
        public static RInterfaceHL getInstance() {
            return SingletonHolder.INSTANCE;
        }

    }

    /**
     * Return the singleton instance of RInterfaceHL. Only the first call to
     * this will establish the rloopHandler.
     * 
     * @param rloopHandler
     *            R REPL handler supplied by client.
     * @return RInterfaceHL singleton instance
     * @throws REngineException
     *             if REngine cannot be created
     */
    public static RInterfaceHL getInstance(RMainLoopCallbacks rloopHandler)
            throws REngineException {
        RInterfaceHL.rloopHandler = rloopHandler;

        RInterfaceHL instance = null;

        try {
            instance = SingletonHolder.getInstance();
        } catch (ExceptionInInitializerError e) {

            // rethrow exception that occurred in the initializer
            // so our caller can deal with it
            Throwable exceptionInInit = e.getCause();
            throw new REngineException(null, exceptionInInit.getMessage());
        }

        return instance;
    }

    /**
     * org.rosuda.REngine.REngine high level R interface.
     */
    private REngine rosudaEngine = null;

    /**
     * Construct new RInterfaceHL. Only ever gets called once by
     * {@link SingletonHolder.initRInterfaceHL}.
     * 
     * @param rloopHandler
     *            R REPL handler supplied by client.
     * @throws REngineException
     *             if R cannot be loaded.
     */
    private RInterfaceHL(RMainLoopCallbacks rloopHandler)
            throws REngineException {

        // tell Rengine code not to die if it can't
        // load the JRI native DLLs. This allows
        // us to catch the UnsatisfiedLinkError
        // ourselves
        System.setProperty("jri.ignore.ule", "yes");

        rosudaEngine = new JRIEngine(new String[] { "--no-save" }, rloopHandler);
    }
}

당신이하려는 일을 성취하는 방법을 이해할 수없는 이유는 아마도 당신이하려는 일이 실제로 의미가 없기 때문일 것입니다. getInstance(x)다른 인수 로 호출 하고 싶지만 항상 같은 객체를 반환합니까? 전화 할 때 당신은 어떤 동작을 원하지되어 getInstance(2)다음과 getInstance(5)?

동일한 객체이지만 내부 값이 다르기를 원합니다. 이것이 여전히 싱글 톤 인 유일한 방법 인 경우, 생성자를 전혀 신경 쓰지 않아도됩니다. getInstance()객체의 나갈 때 값을 설정하기 만하면 됩니다. 물론 싱글 톤에 대한 다른 모든 참조는 이제 다른 내부 값을 가짐을 이해합니다.

반면에 다른 객체 를 원 getInstance(2)하고 getInstance(5)반환하려면 Singleton 패턴을 사용하지 않고 Factory 패턴을 사용합니다.

귀하의 예에서는 싱글 톤을 사용하지 않습니다. Singleton.getInstance가 실제로 정적이라고 가정하면 다음을 수행하십시오.

Singleton obj1 = Singleton.getInstance(3);
Singleton obj2 = Singleton.getInstance(4);

그런 다음 obj2.x의 값은 4가 아니라 3입니다.이 작업을 수행해야하는 경우 일반 클래스로 만드십시오. 값 수가 작고 고정 된 경우을 사용하는 것이 enum좋습니다. 과도한 객체 생성에 문제가있는 경우 (보통 그렇지 않은 경우), 값을 캐싱하는 것을 고려할 수 있습니다 (메모리 누수의 위험없이 캐시를 작성하는 방법이 분명하므로 소스를 확인하거나 도움을 얻을 수 있음).

싱글 톤을 너무 쉽게 과도하게 사용할 수 있으므로이 기사 를 읽어보십시오 .

Singletons가 안티 패턴 인 또 다른 이유는 권장 사항에 따라 개인 생성자를 사용하여 작성하면 서브 클래스를 작성하고 특정 단위 테스트에서 사용하기가 매우 어렵다는 것입니다. 예를 들어 레거시 코드를 유지 관리하는 데 필요합니다.

컨텍스트 역할을하는 Singleton 클래스를 만들려면 구성 파일을 갖고 instance () 내의 파일에서 매개 변수를 읽는 것이 좋습니다.

프로그램을 실행하는 동안 Singleton 클래스를 공급하는 매개 변수가 동적으로 제공되는 경우 Singleton 클래스에 다른 인스턴스를 저장하는 정적 HashMap을 사용하여 각 매개 변수에 대해 하나의 인스턴스 만 생성되도록하십시오.

이것은 싱글 톤은 아니지만 문제를 해결할 수있는 것일 수 있습니다.

public class KamilManager {

  private static KamilManager sharedInstance;

  /**
   * This method cannot be called before calling KamilManager constructor or else
   * it will bomb out.
   * @return
   */
  public static KamilManager getInstanceAfterInitialized() {
    if(sharedInstance == null)
        throw new RuntimeException("You must instantiate KamilManager once, before calling this method");

    return sharedInstance;
}

  public KamilManager(Context context, KamilConfig KamilConfig) {
    //Set whatever you need to set here then call:
  s  haredInstance = this;
  }
}

"상태를 사용하여 싱글 톤을 만드는 방법"으로 문제를 해결하면 상태를 생성자 매개 변수로 전달할 필요가 없습니다. 단일 인스턴스를 얻은 후 상태를 초기화하거나 set 메소드를 사용하는 게시물에 동의합니다.

또 다른 질문은 상태와 싱글 톤을 갖는 것이 좋은가?

우리는 이런 식으로 할 수 없습니다 :

public class Singleton {

    private int x;

    // Private constructor prevents instantiation from other classes
    private Singleton() {}

    /**
     * SingletonHolder is loaded on the first execution of Singleton.getInstance() 
     * or the first access to SingletonHolder.INSTANCE, not before.
     */
    private static class SingletonHolder { 
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance(int x) {
        Singleton instance = SingletonHolder.INSTANCE;
        instance.x = x;
        return instance;
    }
}

어떤 사람들이 주장 할 수는 있지만 생성자에 매개 변수가있는 싱글 톤이 있습니다.

public class Singleton {

    private static String aParameterStored;

    private static final Singleton instance = new Singleton("Param to set");

    private Singleton() {
        // do nothing
    }

    private Singleton(String param) {
        aParameterStored = param;
    }

    public static Singleton getInstance() {
        return instance;
    }

    /*
     * ... stuff you would like the singleton do
     */
}

싱글 톤 패턴 말한다 :

• 싱글턴 클래스의 인스턴스가 하나만 존재하는지 확인하십시오.
• 해당 인스턴스에 대한 글로벌 액세스를 제공합니다.

이 예제와 관련이 있습니다.

왜 속성을 직접 설정하지 않습니까? 매개 변수가있는 생성자를 갖는 싱글 톤을 얻는 방법을 보여주는 교과서 사례이지만 일부 상황에서는 유용 할 수 있습니다. 예를 들어 상속 사례에서 싱글 톤이 일부 슈퍼 클래스 속성을 설정하도록 강제합니다.

나는 이것을 대답으로 게시하는 것이 무서워하지만 아무도 이것에 대해 생각하지 않는 이유를 이해하지 못합니다. 아마도이 대답도 이미 이해하지 못했습니다.

public class example  {
    private volatile static example instance;

    private String string;
    private int iInt = -1; //any number you know you don't want to use here

  private example() {

    //In case someone uses the private method to create a new Instance
    if (instance != null){
      throw new RuntimeException("Use getInstance() method to get the single instance of this class.");
    }
  }

  public synchronized static example getIsntance(){
    if(instance == null){
      instance = new example();
    }
    return instance;
  }

public void methodDoingWork(){
    if(checkInit()){
      //DoSome
    }
  }

  private boolean checkInit(){
    boolean filled = (this.string != null) && (this.iInt != -1);
    return filled;
  }

  public void setString(String string) {
    if(this.string == null){
      this.string = string;
    }else{
      throw new RuntimeException("You try to override an already setValue"); 
    }
  }

  public void setiInt(int iInt) {
    if(this.iInt == -1){
      this.iInt = iInt;
    }else{
      throw new RuntimeException("You try to override an already setValue");
    }
  }
}

getInstance()매번 동일한 인스턴스를 반환하기 때문에 이것이 효과가 있다고 생각합니다. 이것이 많이 잘못되면 삭제하겠습니다.이 주제에 관심이 있습니다.

이것이 일반적인 문제라고 생각합니다. 싱글 톤의 "초기화"를 싱글 톤의 "get"에서 분리하면 작동 할 수 있습니다 (이 예에서는 이중 검사 잠금 변형을 사용함).

public class MySingleton {

    private static volatile MySingleton INSTANCE;

    @SuppressWarnings("UnusedAssignment")
    public static void initialize(
            final SomeDependency someDependency) {

        MySingleton result = INSTANCE;

        if (result != null) {
            throw new IllegalStateException("The singleton has already "
                    + "been initialized.");
        }

        synchronized (MySingleton.class) {
            result = INSTANCE;

            if (result == null) {
                INSTANCE = result = new MySingleton(someDependency);
            } 
        }
    }

    public static MySingleton get() {
        MySingleton  result = INSTANCE;

        if (result == null) {
            throw new IllegalStateException("The singleton has not been "
                    + "initialized. You must call initialize(...) before "
                    + "calling get()");
        }

       return result;
    }

    ...
}

물론 싱글 톤은 "반 패턴 (anti-pattern)"입니다 (가변 상태의 정적 정의를 가정).

불변 값 객체의 고정 세트를 원한다면 열거 형이 좋습니다. 대규모의 개방형 값 집합의 경우 일반적으로 Map구현을 기반으로하는 일부 형식의 리포지토리를 사용할 수 있습니다 . 물론 정적을 다룰 때 스레딩에주의하십시오 (충분히 광범위하게 동기화하거나 ConcurrentMap다른 스레드가 당신을 때리지 않았는지 또는 어떤 형태의 미래를 사용하지 않았는지 확인).

싱글 톤은 일반적으로 반 패턴 으로 간주되며 사용해서는 안됩니다. 코드를 쉽게 테스트 할 수 없습니다.

논쟁이있는 싱글 톤은 어쨌든 말이되지 않습니다-당신이 쓴다면 어떻게 될까요 :

Singleton s = SingletonHolder.getInstance(1);
Singleton t = SingletonHolder.getInstance(2); //should probably throw IllegalStateException

여러 스레드가 동시에 호출하여 둘 이상의 인스턴스가 생성 될 수 있으므로 (다른 값이 다른) 단일 인스턴스 도 스레드로부터 안전하지 않습니다 .getInstancex