Klar Singleton-Instanz in Java

Habe ich eine Singleton-Klasse zum speichern des Status eines Anwendung-Modul.
Diese Klasse einfach eine Menge von class-Variablen mit setter und Getter :

public class ModuleState{

private static ModuleState instance;

private A a;
private B b;
private C c;
..
..
..
..

private ModuleState (){}

public ModuleState getInstance(){
    if(instance==null)
        instance=new ModuleState();

    return instance;
}

}

Zu einem bestimmten Zeitpunkt in den application lifecycle, ich habe den LÖSCHEN müssen Sie das Modul state. Was ich tun ist jetzt zurücksetzen, um ALLE Variablen in ModuleState durch ein clearAll () - Methode wie diese:

public void clearAll(){
    a=null;
    b=null;
    c=null;

    ..
    ..
}

Meine Frage ist folgende : gibt es eine sauberere Methode, dies zu tun-reset? Möglicherweise clearing die singleton-Instanz selbst, ohne zurücksetzen jeder Klasse die variable?

Das problem bei diesem Ansatz ist, dass ich vielleicht das Bedürfnis haben, fügen Sie eine neue Klasse variable, die ModuleState. In diesem Fall muss ich daran denken, fügen Sie eine Zeile in der clearAll () - Methode zum zurücksetzen der neuen variable.

InformationsquelleAutor Nameless | 2013-05-12

11

Was ...
```
public static volatile ModuleState instance = null;

public static void reset() {
    instance = new ModuleState();
}
```
p.s.: als pro Diskussion unten: in einer Multithread-Umgebung ist es sehr wichtig zu synchronisieren, die Zugriff auf die Instanz, weil die JVM darf cache seinen Wert. Sie können volatile wie oben gezeigt. Vielen Dank an alle!

Prost!

Die singleton wäre kein singleton mehr. Wenn ein code speichert das Ergebnis von getInstance() irgendwo, wäre es dann Zugriff auf oder ändern Sie die Vorherige version des Staates. Das muss berücksichtigt werden, bevor Sie diese Lösung.
Ja, Sie haben Recht: es ist ein bisschen gegen die Idee eines Singleton. Darüber hinaus kann es notwendig sein, synchronisieren Sie diese Methode. Aber noch funktionsfähig ist, ist es nicht?
Es hat zum cache ist es irgendwie. Einfach anrufen ModuleState.getInstance().getA().getFoo() hat noch eine chance auf eine veraltete Zustand, wenn ein anderer thread verpasst dem singleton-parallel. Machen getInstance() synchronisiert, ändert sich nichts.
Das gleiche unsafety argument kann dann für einzelne Objekte zurückgegeben getA..Z, so offensichtlich einige praktische Begrenzung "Präzision" muss akzeptiert werden. Machen instance flüchtig und mit diesem Ansatz ist wahrscheinlich eine sehr anständige Lösung zu OP ' s problem.
Den nur letztlich sichere Lösung ist ein massive-Klasse, die nie stellt der A..Z Objekte, sondern können nur abgefragt werden, für die Blatt-Atomare Werte, die Sie halten. Die ganze Klasse müsste synchronized so, dass die reset - Betrieb schließen sich gegenseitig aus jeder .

InformationsquelleAutor Trinimon
2

Nein, dieser Ansatz ist durchaus akzeptabel. Sie sind natürlich die Synchronisierung der Zugang zu diesen Status-Objekte, die in irgendeiner Weise, richtig? sonst riskieren Sie, jemand zu sehen, eine halb-config-Objekt gelöscht.

andere Sache, die Sie tun können, um zu zukunftssicheren Sie sich gegen jede zusätzliche Staates, die in Zukunft aufgenommen ist, speichern Sie alle von Ihrem Staat in eine HashMap, zum Beispiel, statt der einzelnen Felder. auf diese Weise, clear()ing der hashmap wird sichergestellt, dass alle staatlichen ausgelöscht wird, und das hinzufügen der extra-Zustand in der Zukunft sicherer wird

InformationsquelleAutor radai
1

Müssen Sie halten die gleiche Objekt-Instanz, um im Einklang mit dem Singleton-pattern, so dass Ihr Ansatz macht Sinn: die änderung der Mitglieder.

Jedoch, wenn Sie wollte, es zu bereinigen ein wenig, warum nicht einfach eine interne Liste, wie:
```
 ArrayList<Object> members = new ArrayList<Object>();
 //If it actually is Object, there's no need to paramaterize.
 //If you want, you can actually make the members implement a common interface,
 //and parameterize the ArrayList to that.
```
Andere Möglichkeit wäre, ein HashMap, bindet das entscheidende Wort, an das Mitglied.
```
 HashMap<String,Object> members = new HashMap<String,Object>();
 //Again, same parameterization rules apply.
```
Für eine ArrayList oder eine HashMap, die clearAll Methode könnte wie folgt Aussehen:
```
public class ModuleState()
{
    public void clearAll()
    {
          members.clear();
    }
}
```
Diese Methode nicht brauchen, um zu ändern.

InformationsquelleAutor christopher

Werden können, dies kann Ihnen helfen:

public class SingletonBean {

    private static SingletonBean instance = new SingletonBean();
    private static Object privateMutex = new Object();

    private SingletonBean() {
        //to prevent instantiation
    }



public class ObjectsContainer {
    private Object A;
    private Object B;
    private Object C;

    public Object getA() {
        return A;
    }

    public void setA(Object a) {
        A = a;
    }

    public Object getB() {
        return B;
    }

    public void setB(Object b) {
        B = b;
    }

    public Object getC() {
        return C;
    }

    public void setC(Object c) {
        C = c;
    }
}

    private ObjectsContainer objectsContainer;

    private void resetObjectsContainer() {
        objectsContainer = new ObjectsContainer();
    }

    public static SingletonBean getInstance() {
        return SingletonBean.instance;
    }

    public static void clearAll() {
        synchronized (privateMutex) {
            SingletonBean.getInstance().resetObjectsContainer();
        }
    }

    public static ObjectsContainer getObjectsContainer() {
        synchronized (privateMutex) {
            return instance.objectsContainer;
        }
    }
}

public class SomeClass {
    public void someMethod() {
        SingletonBean.getObjectsContainer().getA();
    }
}

InformationsquelleAutor gluckonavt

0

Machen Sie eine innere Klasse zu halten, die Felder, dann ersetzen , dass Beispiel, wenn Sie zurücksetzen möchten. Das schreiben auf dem Spielfeld würde das ändern, um alle drei Felder, die im wesentlichen atomar.
```
public class ModuleState {

private static volatile ModuleState instance;

private static class Values {
    A a;
    B b;
    C c;
}
private volatile Values values = new Values()(

private ModuleState (){}

public ModuleState getInstance(){
    if (instance==null) {
        synchronized (ModuleState.class) {
            if (instance==null) {
                instance = new ModuleState();
            }
        }
    }

    return instance;
}

public synchronized A getA() {
     return values.a;
}

public synchronized void reset() {
    values = new Values();
}
```
Durch die Art und Weise, Ihre null-überprüfung von code für die Initialisierung war nicht threadsicher. Ich fest, dass auch.

Beachten Sie, dass diese Arbeit zu machen, musst du den Verweis auf values flüchtig und synchronisieren Sie alle Zugang zu Ihr, ansonsten (aufgrund der java-memory-Modell) von anderen threads als dem, der ruft reset() kann sehen, dass die alte Referenz.

es scheint, dass das singleton-Muster ist vielleicht nicht die beste Passform hier. wenn Sie ein Objekt haben, das Land, das Sie brauchen, um vollständig zurückgesetzt, dass klingt wie die Art von Sache, die Sie haben Konstruktoren für. Ich brauchen würde, um zu sehen, eine solide Grund für die Einführung der oben genannten code, IMO ist übermäßig kompliziert.
Eigentlich ist es nicht alles erreichen, was mehr als der einfachere Weg, es ist nur erlaubt den client-cache "singleton". Aber es gibt keinen inneren Wert haben, die Art Protokoll: was ist falsch mit darauf, dass die singleton-werden immer neu erworben getInstance?
danke für den thread-sicher beheben
Meinst du diesen, wenn Sie darüber gesprochen, "eine riesige Klasse, die nie stellt von A..Z-Objekte, aber Sie können nur abgefragt werden, für die Blatt-Atomare Werte, die Sie halten. Die ganze Klasse hätte synchronisiert werden, so dass der reset-Betrieb schließen sich gegenseitig aus, jeder" ? Durch die Art, wie ich diese Lösung irgendwelche Nachteile? Ist dies sicher?

InformationsquelleAutor Bohemian

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.