Singleton dengan Argumen di Jawa

Saya sedang membaca artikel Singleton di Wikipedia dan saya menemukan contoh ini:

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

Walaupun saya sangat menyukai cara Singleton ini berperilaku, saya tidak dapat melihat bagaimana mengadaptasinya untuk memasukkan argumen ke konstruktor. Apa cara yang disukai untuk melakukan ini di Jawa? Apakah saya harus melakukan sesuatu seperti ini?

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

Terima kasih!

Sunting: Saya pikir saya telah memulai badai kontroversi dengan keinginan saya untuk menggunakan Singleton. Biarkan saya menjelaskan motivasi saya dan semoga seseorang dapat menyarankan ide yang lebih baik. Saya menggunakan kerangka kerja komputasi grid untuk menjalankan tugas secara paralel. Secara umum, saya memiliki sesuatu seperti ini:

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

Apa yang terjadi adalah bahwa meskipun saya hanya meneruskan referensi ke data saya ke semua tugas, ketika tugas-tugas bersambung, data akan disalin berulang-ulang. Yang ingin saya lakukan adalah membagikan objek di antara semua tugas. Secara alami, saya dapat memodifikasi kelas seperti:

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

Seperti yang Anda lihat, bahkan di sini saya memiliki masalah bahwa melewati jalur file yang berbeda tidak ada artinya setelah yang pertama dilewati. Inilah sebabnya saya menyukai ide untuk toko yang diposting dalam jawaban. Bagaimanapun, daripada memasukkan logika untuk memuat file dalam metode run, saya ingin abstrak logika ini menjadi kelas Singleton. Saya tidak akan memberikan contoh lain, tetapi saya harap Anda mendapatkan idenya. Tolong biarkan saya mendengar ide Anda untuk cara yang lebih elegan untuk mencapai apa yang saya coba lakukan. Terima kasih lagi!

Saya akan menjelaskan maksud saya: singleton dengan parameter bukan singleton .

Singleton, menurut definisi, adalah objek yang Anda inginkan tidak lebih dari satu kali. Jika Anda mencoba memberi makan parameter ke konstruktor, apa gunanya singleton?

Anda memiliki dua opsi. Jika Anda ingin singleton diinisialisasi dengan beberapa data, Anda dapat memuatnya dengan data setelah instantiation , seperti:

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

Jika operasi yang dilakukan singleton Anda berulang, dan dengan parameter yang berbeda setiap kali, Anda mungkin juga meneruskan parameter ke metode utama yang dijalankan:

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

Bagaimanapun, instantiasi akan selalu menjadi parameter-kurang. Kalau tidak, lajang Anda bukan lajang.

Saya pikir Anda memerlukan sesuatu seperti pabrik untuk memiliki objek dengan berbagai parameter instantiated dan digunakan kembali. Ini dapat diimplementasikan dengan menggunakan sinkronisasi HashMapatau ConcurrentHashMapmemetakan parameter ( Integercontohnya) ke kelas parameterabel 'tunggal' Anda.

Meskipun Anda mungkin sampai pada titik di mana Anda harus menggunakan kelas non-singleton reguler (sebagai gantinya membutuhkan 10.000 singleton dengan parametrized berbeda).

Berikut adalah contoh untuk toko tersebut:

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

Untuk mendorongnya lebih jauh, Java enumjuga dapat dianggap (atau digunakan sebagai) lajang parametrized, meskipun hanya memperbolehkan varian statis nomor tetap.

Namun, jika Anda membutuhkan solusi ¹ terdistribusi , pertimbangkan beberapa solusi caching lateral. Misalnya: EHCache, Terracotta, dll.

¹ dalam arti menjangkau beberapa VM di beberapa komputer.

Anda dapat menambahkan metode inisialisasi yang dapat dikonfigurasi untuk memisahkan instantiation dari mendapatkan.

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

}

Kemudian Anda dapat menelepon Singleton.init(123)sekali untuk mengkonfigurasinya, misalnya di startup aplikasi Anda.

Anda juga dapat menggunakan pola Builder jika Anda ingin menunjukkan bahwa beberapa parameter wajib.

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

    }


}

Kemudian Anda dapat membuat / membuat instance / parametrized sebagai berikut:

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

Pernyataan " singleton dengan parameter bukan singleton " tidak sepenuhnya benar . Kita perlu menganalisis ini dari perspektif aplikasi daripada dari perspektif kode.

Kami membangun kelas tunggal untuk membuat satu instance objek dalam satu aplikasi dijalankan. Dengan memiliki konstruktor dengan parameter, Anda dapat membangun fleksibilitas ke dalam kode Anda untuk mengubah beberapa atribut objek tunggal Anda setiap kali Anda menjalankan aplikasi Anda. Ini bukan pelanggaran pola Singleton. Sepertinya ini pelanggaran jika Anda melihatnya dari perspektif kode.

Pola Desain ada untuk membantu kita menulis kode yang fleksibel dan dapat diperpanjang, bukan untuk menghalangi kita menulis kode yang baik.

Gunakan getter dan setter untuk mengatur variabel dan menjadikan konstruktor default pribadi. Kemudian gunakan:

Singleton.getInstance().setX(value);

Terkejut bahwa tidak ada yang menyebutkan bagaimana logger dibuat / diambil. Sebagai contoh, di bawah ini menunjukkan bagaimana Log4J logger diambil.

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

Ada beberapa tingkatan tipuan, tetapi kuncinya adalah di bawah metode yang cukup banyak menceritakan segalanya tentang cara kerjanya. Ini menggunakan tabel hash untuk menyimpan logger yang ada dan kunci berasal dari nama. Jika logger tidak ada untuk memberi nama, logger menggunakan pabrik untuk membuat logger dan kemudian menambahkannya ke tabel hash.

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

Modifikasi pola Singleton yang menggunakan inisialisasi Bill Pugh pada idiom pemegang permintaan . Ini adalah utas aman tanpa overhead konstruksi bahasa khusus (yaitu volatile atau disinkronkan):

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

Alasan mengapa Anda tidak bisa memahami bagaimana mencapai apa yang Anda coba lakukan mungkin karena apa yang Anda coba lakukan tidak benar-benar masuk akal. Anda ingin menelepon getInstance(x)dengan argumen yang berbeda, tetapi selalu mengembalikan objek yang sama? Perilaku apa yang Anda inginkan saat menelepon getInstance(2)dan kemudian getInstance(5)?

Jika Anda ingin objek yang sama tetapi untuk nilai internal yang berbeda, yang merupakan satu-satunya cara itu masih tunggal, maka Anda tidak perlu peduli sama sekali dengan konstruktor; Anda cukup menetapkan nilai pada getInstance()pada jalan keluar objek. Tentu saja, Anda mengerti bahwa semua referensi Anda yang lain tentang singleton sekarang memiliki nilai internal yang berbeda.

Jika Anda ingin getInstance(2)dan getInstance(5)mengembalikan objek yang berbeda, di sisi lain, Anda tidak menggunakan pola Singleton, Anda menggunakan pola Factory.

Dalam contoh Anda, Anda tidak menggunakan singleton. Perhatikan bahwa jika Anda melakukan hal berikut (dengan asumsi bahwa Singleton.getInstance sebenarnya statis):

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

Maka nilai-nilai obj2.x adalah 3, bukan 4. Jika Anda perlu melakukan ini, jadikan ini kelas biasa. Jika jumlah nilai kecil dan tetap, Anda dapat mempertimbangkan menggunakan enum. Jika Anda mengalami masalah dengan pembuatan objek berlebihan (yang biasanya tidak terjadi), maka Anda dapat mempertimbangkan nilai caching (dan memeriksa sumber atau mendapatkan bantuan dengan itu, karena jelas cara membuat cache tanpa bahaya kebocoran memori).

Anda juga mungkin ingin membaca artikel ini karena lajang dapat dengan mudah digunakan secara berlebihan.

Alasan lain mengapa Singletons anti-pola adalah bahwa jika ditulis sesuai rekomendasi, dengan konstruktor pribadi, mereka sangat sulit untuk subkelas dan terkonfigurasi untuk digunakan dalam unit test tertentu. Akan diperlukan dalam memelihara kode warisan, misalnya.

Jika Anda ingin membuat kelas Singleton yang berfungsi sebagai Konteks, cara yang baik adalah memiliki file konfigurasi dan membaca parameter dari file di dalam instance ().

Jika parameter yang memberi makan kelas Singleton didapat secara dinamis selama menjalankan program Anda, cukup gunakan HashMap statis yang menyimpan instance berbeda di kelas Singleton Anda untuk memastikan bahwa untuk setiap parameter, hanya satu instance dibuat.

Ini bukan singleton, tetapi mungkin sesuatu yang bisa memperbaiki masalah Anda.

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

Jika kita menganggap masalah sebagai "cara membuat singleton dengan status", maka tidak perlu meneruskan status sebagai parameter konstruktor. Saya setuju dengan posting yang menginisialisasi negara atau menggunakan metode set setelah mendapatkan instance singleton.

Pertanyaan lain adalah: apakah baik memiliki singleton dengan negara?

Tidak bisakah kita melakukan sesuatu seperti ini:

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

Terlepas dari apa yang beberapa orang mungkin nyatakan, ini adalah singleton dengan parameter dalam konstruktor

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
     */
}

Pola tunggal mengatakan:

• memastikan bahwa hanya satu instance dari kelas singleton yang pernah ada
• memberikan akses global ke instance itu.

yang dihormati dengan contoh ini.

Mengapa tidak langsung mengatur properti? Ini kasus buku teks untuk menunjukkan bagaimana kita bisa mendapatkan singleton yang memiliki konstruktor dengan parameter tetapi bisa berguna dalam beberapa situasi. Misalnya dalam kasus warisan memaksa singleton untuk mengatur beberapa properti superclass.

Saya takut memposting ini sebagai jawaban, tapi saya tidak mengerti mengapa tidak ada yang berpikir tentang ini, mungkin jawaban ini juga sudah diberikan, saya hanya tidak memahaminya.

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

Karena getInstance()mengembalikan Instance yang sama setiap kali, saya pikir ini bisa berhasil. Jika ini salah pada banyak hal yang akan saya hapus, saya hanya tertarik dengan topik ini.

Saya pikir ini adalah masalah umum. Memisahkan "inisialisasi" singleton dari "get" singleton mungkin berhasil (contoh ini menggunakan variasi penguncian ganda diperiksa).

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

    ...
}

Singleton, tentu saja, merupakan "anti-pola" (dengan asumsi definisi statis dengan keadaan variabel).

Jika Anda ingin satu set objek nilai tetap yang tidak dapat diubah, maka enum adalah cara untuk melakukannya. Untuk sekumpulan nilai besar, mungkin ujung terbuka, Anda bisa menggunakan Repositori dari beberapa bentuk - biasanya berdasarkan Mapimplementasi. Tentu saja, ketika Anda berurusan dengan statika, berhati-hatilah dengan threading (baik menyinkronkan cukup luas atau menggunakan ConcurrentMapbaik memeriksa bahwa utas lain belum mengalahkan Anda atau menggunakan beberapa bentuk futures).

Lajang umumnya dianggap anti-pola dan tidak boleh digunakan. Mereka tidak membuat kode mudah untuk diuji.

Lajang dengan argumen tidak masuk akal - apa yang akan terjadi jika Anda menulis:

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

Singleton Anda juga tidak aman utas karena beberapa utas dapat membuat panggilan simultan untuk getInstancemenghasilkan lebih dari satu instance yang dibuat (mungkin dengan nilai yang berbeda dari x).