Einzelne Instanziierung mit Argumenten

Habe ich eine Klasse (RInterfaceHL), die Anrufe einer anderen Klasse (JRIEngine), die native Methoden auf einem single-threaded-Anwendung. Also ich will nur eine einzige Instanz meiner Klasse (RInterfaceHL) pro JVM.

Kann ich die singleton-Muster mit statischen Initialisierung, um sicherzustellen, dass nur eine einzelne Instanziierung von RInterfaceHL, aber RInterfaceHL muss, erstellen Sie eine Instanz der JRIEngine und versorgen Sie mit einem loopback-parameter. Wie kann ich in eine thread-sichere Weise in einer einzigen Instanz RInterfaceHL akzeptiert eine loopback-parameter für den Bau eines einzigen JRIEngine? Ich bin mit JDK6.

NB: Diese ähnlich benannten Frage keine Antwort auf meine Frage.

  • Beachten Sie, dass Singletons sind nicht pro JVM, aber pro classloader. Das singleton-pattern in Java wird erhalten, indem die Klasse mit dual-Aufgaben - Instanz-Erstellung und der tatsächlichen Verantwortung. Der Instanz-Erstellung Verantwortung umgegangen wird, wenn die Klasse geladen wird, indem der classloader (und es können auch mehrere sein classloadern pro JVM).
InformationsquelleAutor tekumara | 2009-09-11
  1. 6

    Änderung des Singleton-Muster verwendet Bill Pugh der initialization on demand holder idiom. Dies ist thread-sicher, ohne den Aufwand für spezielle Sprachkonstrukte (d.h. flüchtige oder synchronisiert):

    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);
    }
}
    InformationsquelleAutor tekumara
  2. 4
    public class RInterfaceHL {
    private static RInterfaceHL theInstance;

    private final JRIEngine engine;

    private RInterfaceHL(JRIEngine engine) {
        this.engine = engine;
    }

    public static synchronized RInterfaceHL getInstance() {
        if (theInstance == null) {
            throw new IllegalStateException("not initialized");
        }
        return theInstance;
    }
    public static synchronized void initialize(String loopback) {
        if (theInstance != null) {
            throw new IllegalStateException("already initialized");
        }
        theInstance = new RInterfaceHL(new JRIEngine(loopback));
    }

    ...
}

    EDIT: ich sollte hinzufügen, dass, wenn Sie sind, Dinge aufzubauen, zu laufen in einem servlet oder ähnliche Behälter, mit dem reinen Singleton-Muster ist wahrscheinlich eine schlechte Idee. Einer der IoC /dependency injection-Mechanismen ist eine bessere Idee; z.B. Frühling wie vorgeschlagen in einer anderen Antwort. Dadurch können Sie den Gültigkeitsbereich des "Singleton" auf den container.

    InformationsquelleAutor Stephen C
  3. 0

    Es wäre des guten zuviel, wenn Sie nur tun, ein kleines Programm, aber ein dependency injection framework wie Spring Framework kann Ihnen singleton-Verhalten, ohne die Notwendigkeit, manuell zu konstruieren und initialisieren Sie das statische Objekt von hand.

    Dependency injection "container" zu konstruieren und verdrahten Sie singleton und seine Abhängigkeit von Klassen zusammen, und kann so konfiguriert werden, um Ihrem Objekt ein singleton-Instanz innerhalb des Containers.

    Gibt es ein bisschen eine Lernkurve, wenn Sie nicht verwendet haben Frühling vor, aber es ist ein sehr beliebtes framework, und wahrscheinlich wird Sie gut dienen.

    InformationsquelleAutor Andy White
Schreibe einen Kommentar