Ich habe den Artikel über Singleton auf Wikipedia gelesen und bin auf folgendes Beispiel gestoßen:

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;
    }
}

Obwohl mir das Verhalten dieses Singleton sehr gefällt, kann ich nicht verstehen, wie man es anpasst, um Argumente in den Konstruktor einzubeziehen. Was ist der bevorzugte Weg, um dies in Java zu tun? Müsste ich so etwas machen?

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;
    }
}

Vielen Dank!

Edit: Ich denke, ich habe einen Sturm der Kontroversen mit meinem Wunsch begonnen, Singleton zu verwenden. Lassen Sie mich meine Motivation erklären und hoffentlich kann jemand eine bessere Idee vorschlagen. Ich verwende ein Grid-Computing-Framework, um Aufgaben parallel auszuführen. Im Allgemeinen habe ich so etwas:

// 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).
    }
}

Was passiert ist, dass, obwohl ich lediglich einen Verweis auf meine Daten an alle Aufgaben weitergebe, die Daten immer wieder kopiert werden, wenn die Aufgaben serialisiert werden. Ich möchte das Objekt für alle Aufgaben freigeben. Natürlich könnte ich die Klasse so ändern:

// 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).
    }
}

Wie Sie sehen, habe ich auch hier das Problem, dass das Übergeben eines anderen Dateipfads nichts bedeutet, nachdem der erste übergeben wurde. Aus diesem Grund mag ich die Idee für eineGeschäft Das wurde in den Antworten gepostet. Anstatt die Logik zum Laden der Datei in die run-Methode aufzunehmen, wollte ich diese Logik in eine Singleton-Klasse abstrahieren. Ich werde kein weiteres Beispiel nennen, aber ich hoffe, dass Sie auf die Idee kommen. Bitte lassen Sie mich Ihre Ideen für einen eleganteren Weg hören, um das zu erreichen, was ich versuche zu tun. Danke nochmal!