pengembangan-web-mp-pd.com

Apa cara yang efisien untuk menerapkan pola tunggal di Jawa?

Apa cara yang efisien untuk menerapkan pola tunggal di Jawa?

752

Gunakan enum:

public enum Foo {
    INSTANCE;
}

Joshua Bloch menjelaskan pendekatan ini dalam Pembicaraan Java Reloaded yang efektif di Google I/O 2008: tautan ke video . Lihat juga slide 30-32 dari presentasinya ( effective_Java_reloaded.pdf ):

Cara yang Benar untuk Menerapkan Singleton yang Berhubungan Serial

public enum Elvis {
    INSTANCE;
    private final String[] favoriteSongs =
        { "Hound Dog", "Heartbreak Hotel" };
    public void printFavorites() {
        System.out.println(Arrays.toString(favoriteSongs));
    }
}

Edit: Bagian online dari "Java Efektif" mengatakan: 

"Pendekatan ini secara fungsional setara dengan pendekatan lapangan publik, kecuali bahwa itu lebih ringkas, menyediakan mesin serialisasi secara gratis, dan memberikan jaminan kuat terhadap berbagai instantiasi, bahkan dalam menghadapi serangan bersambung atau refleksi. belum diadopsi secara luas, tipe enum elemen tunggal adalah cara terbaik untuk mengimplementasikan singleton. "

743
Stephen Denne

Bergantung pada penggunaannya, ada beberapa jawaban "benar".

Karena Java5 cara terbaik untuk melakukannya adalah dengan menggunakan enum:

public enum Foo {
   INSTANCE;
}

Sebelum Java5, kasus paling sederhana adalah:

public final class Foo {

    private static final Foo INSTANCE = new Foo();

    private Foo() {
        if (INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return INSTANCE;
    }

    public Object clone() throws CloneNotSupportedException{
        throw new CloneNotSupportedException("Cannot clone instance of this class");
    }
}

Mari kita bahas kodenya. Pertama, Anda ingin kelas menjadi final. Dalam hal ini, saya telah menggunakan kata kunci final untuk memberi tahu pengguna bahwa ini final. Maka Anda perlu menjadikan konstruktor sebagai pribadi untuk mencegah pengguna membuat Foo mereka sendiri. Melempar pengecualian dari konstruktor mencegah pengguna untuk menggunakan refleksi untuk membuat Foo kedua. Kemudian Anda membuat bidang private static final Foo untuk menampung satu-satunya contoh, dan metode public static Foo getInstance() untuk mengembalikannya. Spesifikasi Java memastikan bahwa konstruktor hanya dipanggil ketika kelas pertama kali digunakan.

Ketika Anda memiliki objek yang sangat besar atau kode konstruksi yang berat DAN juga memiliki metode atau bidang statis yang dapat diakses lainnya yang mungkin digunakan sebelum instance diperlukan, maka dan hanya dengan demikian Anda perlu menggunakan inisialisasi malas.

Anda dapat menggunakan private static class untuk memuat instance. Kode tersebut kemudian akan terlihat seperti:

public final class Foo {

    private static class FooLoader {
        private static final Foo INSTANCE = new Foo();
    }

    private Foo() {
        if (FooLoader.INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }
}

Karena baris private static final Foo INSTANCE = new Foo(); hanya dieksekusi ketika kelas FooLoader benar-benar digunakan, ini menangani instantiation malas, dan apakah dijamin aman thread.

Ketika Anda juga ingin dapat membuat serial objek Anda, Anda perlu memastikan deserialisasi tidak akan membuat salinan.

public final class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    private static class FooLoader {
        private static final Foo INSTANCE = new Foo();
    }

    private Foo() {
        if (FooLoader.INSTANCE != null) {
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }

    @SuppressWarnings("unused")
    private Foo readResolve() {
        return FooLoader.INSTANCE;
    }
}

Metode readResolve() akan memastikan satu-satunya instance akan dikembalikan, bahkan ketika objek itu serial dalam menjalankan program Anda sebelumnya.

224
Roel Spilker

Solusi yang diposting oleh Stu Thompson berlaku di Java5.0 dan yang lebih baru. Tapi saya lebih suka tidak menggunakannya karena saya pikir itu rawan kesalahan.

Sangat mudah untuk melupakan pernyataan yang tidak stabil dan sulit untuk memahami mengapa itu perlu. Tanpa volatile kode ini tidak akan aman lagi karena antipattern penguncian diperiksa ulang. Lihat lebih lanjut tentang ini dalam paragraf 16.2.4 dari Java Concurrency in Practice . Singkatnya: Pola ini (sebelum Java5.0 atau tanpa pernyataan volatile) dapat mengembalikan referensi ke objek Bar yang (masih) dalam keadaan salah.

Pola ini diciptakan untuk optimalisasi kinerja. Tapi ini benar-benar bukan masalah nyata lagi. Kode inisialisasi malas berikut ini cepat dan - yang lebih penting - lebih mudah dibaca.

class Bar {
    private static class BarHolder {
        public static Bar bar = new Bar();
    }

    public static Bar getBar() {
        return BarHolder.bar;
    }
}
121
Benno Richters

Thread aman di Java 5+:

class Foo {
    private static volatile Bar bar = null;
    public static Bar getBar() {
        if (bar == null) {
            synchronized(Foo.class) {
                if (bar == null)
                    bar = new Bar(); 
            }
        }
        return bar;
    }
}

EDIT: Perhatikan pengubah volatile di sini. :) Penting karena tanpa itu, utas lainnya tidak dijamin oleh JMM (Java Memory Model) untuk melihat perubahan nilainya. Sinkronisasi tidak menangani hal itu - itu hanya membuat serial akses ke blok kode itu.

EDIT 2 : @ Jawaban Bno merinci pendekatan yang direkomendasikan oleh Bill Pugh (FindBugs) dan dapat diperdebatkan lebih baik. Baca dan ikutilah jawabannya.

94
Stu Thompson

Lupa inisialisasi malas , ini terlalu bermasalah. Ini adalah solusi paling sederhana:

public class A {    

    private static final A INSTANCE = new A();

    private A() {}

    public static A getInstance() {
        return INSTANCE;
    }
}
90
Jonathan

Pastikan Anda benar-benar membutuhkannya. Lakukan google untuk "anti-pola tunggal" untuk melihat beberapa argumen yang menentangnya. Saya kira tidak ada yang salah dengan itu tetapi itu hanya mekanisme untuk mengekspos beberapa sumber daya global/data jadi pastikan bahwa ini adalah cara terbaik. Secara khusus saya telah menemukan injeksi ketergantungan lebih berguna terutama jika Anda juga menggunakan tes unit karena DI memungkinkan Anda untuk menggunakan sumber daya yang diejek untuk tujuan pengujian.

47
Neil Burroughs

Jangan lupa Singleton hanya Singleton untuk Classloader yang memuatnya. Jika Anda menggunakan banyak loader (Wadah), masing-masing BISA memiliki versi Singleton sendiri.

26
Javamann

Saya bingung dengan beberapa jawaban yang menyarankan DI sebagai alternatif untuk menggunakan lajang; ini adalah konsep yang tidak terkait. Anda dapat menggunakan DI untuk menyuntikkan instance tunggal atau non-tunggal (mis. Per-utas). Setidaknya ini benar jika Anda menggunakan Spring 2.x, saya tidak bisa berbicara untuk kerangka DI lainnya.

Jadi jawaban saya untuk OP adalah (dalam semua kecuali kode sampel yang paling sepele) untuk:

  1. Gunakan kerangka kerja DI seperti Spring
  2. Jadikan itu bagian dari konfigurasi DI Anda apakah dependensi Anda adalah lajang, lingkup permintaan, ruang lingkup sesi, atau apa pun.

Pendekatan ini memberi Anda arsitektur Nice terpisah (dan karena itu fleksibel dan dapat diuji) di mana apakah menggunakan singleton adalah detail implementasi yang mudah dibalik (asalkan singlet yang Anda gunakan adalah threadsafe, tentu saja).

21
Andrew Swan

Sangat pertimbangkan mengapa Anda membutuhkan singleton sebelum menulisnya. Ada perdebatan semu-religius tentang penggunaannya yang bisa dengan mudah Anda temukan jika Anda menggunakan google singleton di Jawa.

Secara pribadi saya mencoba untuk menghindari lajang sesering mungkin karena berbagai alasan, sekali lagi sebagian besar dapat ditemukan dengan googling lajang. Saya merasa bahwa cukup sering lajang disalahgunakan karena mudah dipahami oleh semua orang, mereka digunakan sebagai mekanisme untuk memasukkan data "global" ke dalam desain OO dan digunakan karena mudah untuk mengelak dari objek manajemen siklus hidup (atau benar-benar memikirkan bagaimana Anda dapat melakukan A dari dalam B). Lihatlah hal-hal seperti Inversion of Control (IoC) atau Dependency Injection (DI) untuk jalan tengah yang bagus.

Jika Anda benar-benar membutuhkannya maka wikipedia memiliki contoh yang bagus tentang implementasi singleton yang tepat.

20
Aidos

Berikut adalah 3 pendekatan berbeda

1) Enum

/**
* Singleton pattern example using Java Enumj
*/
public enum EasySingleton{
    INSTANCE;
}

2) Pengecekan ganda Penguncian/pemuatan malas

/**
* Singleton pattern example with Double checked Locking
*/
public class DoubleCheckedLockingSingleton{
     private static volatile DoubleCheckedLockingSingleton INSTANCE;

     private DoubleCheckedLockingSingleton(){}

     public static DoubleCheckedLockingSingleton getInstance(){
         if(INSTANCE == null){
            synchronized(DoubleCheckedLockingSingleton.class){
                //double checking Singleton instance
                if(INSTANCE == null){
                    INSTANCE = new DoubleCheckedLockingSingleton();
                }
            }
         }
         return INSTANCE;
     }
}

3) Metode pabrik statis

/**
* Singleton pattern example with static factory method
*/

public class Singleton{
    //initailzed during class loading
    private static final Singleton INSTANCE = new Singleton();

    //to prevent creating another instance of Singleton
    private Singleton(){}

    public static Singleton getSingleton(){
        return INSTANCE;
    }
}
16
Abhijit Gaikwad

Saya menggunakan Spring Framework untuk mengelola lajang saya. Itu tidak menegakkan "keanehan" kelas (yang sebenarnya tidak bisa Anda lakukan jika ada beberapa kelas yang terlibat) tetapi menyediakan cara yang sangat mudah untuk membangun dan mengkonfigurasi pabrik yang berbeda untuk membuat berbagai jenis objek.

13
Matt

Versi 1:

public class MySingleton {
    private static MySingleton instance = null;
    private MySingleton() {}
    public static synchronized MySingleton getInstance() {
        if(instance == null) {
            instance = new MySingleton();
        }
        return instance;
    }
}

Pemuatan malas, aman dengan pemblokiran, kinerja rendah karena synchronized.

Versi 2:

public class MySingleton {
    private MySingleton() {}
    private static class MySingletonHolder {
        public final static MySingleton instance = new MySingleton();
    }
    public static MySingleton getInstance() {
        return MySingletonHolder.instance;
    }
}

Pemuatan malas, aman dengan non-blocking, kinerja tinggi.

11
coderz

Wikipedia memiliki beberapa contoh dari lajang, juga di Jawa. Implementasi Java 5 terlihat cukup lengkap, dan aman untuk digunakan (penguncian dua kali diperiksa).

10
macbirdie

Jika Anda tidak perlu memuat malas, cukup coba

public class Singleton {
    private final static Singleton INSTANCE = new Singleton();

    private Singleton() {}

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

    protected Object clone() {
        throw new CloneNotSupportedException();
    }
}

Jika Anda ingin memuat malas dan Anda ingin Singleton Anda aman dari thread, coba pola periksa-ganda 

public class Singleton {
        private static Singleton instance = null;

        private Singleton() {}

        public static Singleton getInstance() { 
              if(null == instance) {
                  synchronized(Singleton.class) {
                      if(null == instance) {
                          instance = new Singleton();
                      }
                  }
               }
               return instance;
        }

        protected Object clone() {
            throw new CloneNotSupportedException();
        }
}

Karena pola pemeriksaan ganda tidak dijamin berfungsi (karena beberapa masalah dengan kompiler, saya tidak tahu apa-apa lagi tentang itu.), Anda juga dapat mencoba menyinkronkan seluruh metode getInstance atau membuat registri untuk semua Singletons Anda. 

10
Aleksi Yrttiaho

Saya akan mengatakan Enum singleton 

Singleton menggunakan enum di Jawa umumnya cara untuk mendeklarasikan enum singleton. Enum singleton dapat berisi variabel instan dan metode instance. Demi kesederhanaan, juga perhatikan bahwa jika Anda menggunakan metode instance apa pun dari yang Anda butuhkan untuk memastikan keamanan metode tersebut jika hal itu memengaruhi keadaan objek.

Penggunaan enum sangat mudah diimplementasikan dan tidak memiliki kelemahan tentang objek serial, yang harus dielakkan dengan cara lain.

/**
* Singleton pattern example using Java Enum
*/
public enum Singleton {
        INSTANCE;
        public void execute (String arg) {
                //perform operation here
        }
}

Anda dapat mengaksesnya dengan Singleton.INSTANCE, jauh lebih mudah daripada memanggil metode getInstance() di Singleton.

1.12 Serialisasi dari Konstanta Enum

Konstanta Enum diserialisasi secara berbeda dari objek serialable atau externalizable biasa. Bentuk serial konstanta enum hanya terdiri atas namanya; nilai bidang konstanta tidak hadir dalam formulir. Untuk membuat serial suatu konstanta enum, ObjectOutputStream menulis nilai yang dikembalikan oleh metode nama konstanta enum. Untuk menghilangkan desalisasi konstanta enum, ObjectInputStream membaca nama konstanta dari stream; konstanta deserialized kemudian diperoleh dengan memanggil metode Java.lang.Enum.valueOf, melewati tipe enum konstanta bersama dengan nama konstanta yang diterima sebagai argumen. Seperti objek serializable atau eksternal lainnya, konstanta enum dapat berfungsi sebagai target referensi belakang muncul kemudian dalam aliran serialisasi.

Proses dimana konstanta enum diserialisasi tidak dapat dikustomisasi: writeObject spesifik kelas, readObject, readObjectNoData, writeReplace, dan readResolve metode yang didefinisikan oleh tipe enum diabaikan selama serialisasi dan deserialisasi. Demikian pula, setiap deklarasi bidang serialPersistentFields atau serialVersionUID juga diabaikan - semua tipe enum memiliki serialVersionUID tetap dari 0L. Mendokumentasikan bidang dan data berseri serial untuk tipe enum tidak perlu, karena tidak ada variasi dalam tipe data yang dikirim.

Dikutip dari Oracle docs

Masalah lain dengan Singletons konvensional adalah bahwa sekali Anda mengimplementasikan antarmuka Serializable, mereka tidak lagi tetap Singleton karena metode readObject() selalu mengembalikan contoh baru seperti konstruktor di Jawa. Ini dapat dihindari dengan menggunakan readResolve() dan membuang instance yang baru dibuat dengan mengganti dengan singleton seperti di bawah ini 

 // readResolve to prevent another instance of Singleton
 private Object readResolve(){
     return INSTANCE;
 }

Ini bisa menjadi lebih rumit jika Kelas Singleton Anda mempertahankan keadaan, karena Anda perlu membuatnya sementara, tetapi dengan di Enum Singleton, Serialisasi dijamin oleh JVM.


Baca Baik

  1. Pola Singleton
  2. Enum, Lajang dan Deserialisasi
  3. Penguncian dua kali lipat dan pola Singleton
8
NullPoiиteя
There are 4 ways to create a singleton in Java.

1- eager initialization singleton

    public class Test{
        private static final Test test = new Test();
        private Test(){}
        public static Test getTest(){
            return test;
        }
    }

2- lazy initialization singleton (thread safe)

    public class Test {
         private static volatile Test test;
         private Test(){}
         public static Test getTest() {
            if(test == null) {
                synchronized(Test.class) {
                    if(test == null){test = new Test();
                }
            }
         }

        return test;
    }


3- Bill Pugh Singleton with Holder Pattern (Preferably the best one)

    public class Test {

        private Test(){}

        private static class TestHolder{
            private static final Test test = new Test();
        }

        public static Test getInstance(){
            return TestHolder.test;
        }
    }

4- enum singleton
      public enum MySingleton {
        INSTANCE;
    private MySingleton() {
        System.out.println("Here");
    }
}
7
Dheeraj Sachan

Ini adalah bagaimana menerapkan singleton sederhana:

public class Singleton {
    // It must be static and final to prevent later modification
    private static final Singleton INSTANCE = new Singleton();
    /** The constructor must be private to prevent external instantiation */ 
    private Singleton(){}
    /** The public static method allowing to get the instance */
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

Ini adalah cara malas membuat singleton Anda:

public class Singleton {
    // The constructor must be private to prevent external instantiation   
    private Singleton(){}
    /** The public static method allowing to get the instance */
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    /** 
     * The static inner class responsible for creating your instance only on demand,
     * because the static fields of a class are only initialized when the class
     * is explicitly called and a class initialization is synchronized such that only 
     * one thread can perform it, this rule is also applicable to inner static class
     * So here INSTANCE will be created only when SingletonHolder.INSTANCE 
     * will be called
     */
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
}
4
Nicolas Filotto

Anda perlu memeriksa ulang idiom jika Anda perlu memuat variabel instan dari sebuah kelas. Jika Anda perlu memuat variabel statis atau tunggal dengan malas, Anda perlu inisilisasi pada pemegang permintaan idiom. 

Selain itu, jika singleton perlu seriliazble, semua bidang lainnya harus bersifat sementara dan metode readResolve () perlu diimplementasikan untuk menjaga invarian objek singleton. Jika tidak, setiap kali objek di-deserialized, instance baru dari objek akan dibuat. Apa yang readResolve () lakukan adalah mengganti objek baru yang dibaca oleh readObject (), yang memaksa objek baru itu menjadi sampah yang dikumpulkan karena tidak ada variabel yang merujuk padanya.

public static final INSTANCE == ....
private Object readResolve() {
  return INSTANCE; // original singleton instance.
} 
3
Onur

Berbagai cara untuk membuat objek tunggal:

  1. Sesuai Joshua Bloch - Enum akan menjadi yang terbaik.

  2. anda dapat menggunakan penguncian cek ganda juga.

  3. Bahkan kelas statis dalam dapat digunakan.

3
Shailendra Singh

Enum singleton

Cara paling sederhana untuk mengimplementasikan Singleton yang aman-threaded adalah menggunakan Enum

public enum SingletonEnum {
  INSTANCE;
  public void doSomething(){
    System.out.println("This is a singleton");
  }
}

Kode ini berfungsi sejak diperkenalkannya Enum di Java 1.5

Penguncian ganda diperiksa

Jika Anda ingin kode singleton "klasik" yang berfungsi di lingkungan multithreaded (mulai dari Java 1.5) Anda harus menggunakan yang ini.

public class Singleton {

  private static volatile Singleton instance = null;

  private Singleton() {
  }

  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class){
        if (instance == null) {
          instance = new Singleton();
        }
      }
    }
    return instance ;
  }
}

Ini tidak aman sebelum 1,5 karena penerapan kata kunci yang mudah menguap berbeda.

Pemuatan awal Singleton (bekerja bahkan sebelum Java 1.5)

Implementasi ini instantiates singleton ketika kelas dimuat dan memberikan keamanan thread.

public class Singleton {

  private static final Singleton instance = new Singleton();

  private Singleton() {
  }

  public static Singleton getInstance() {
    return instance;
  }

  public void doSomething(){
    System.out.println("This is a singleton");
  }

}
3
Dan Moldovan

Untuk JSE 5.0 dan di atasnya, gunakan pendekatan Enum, jika tidak gunakan pendekatan static singleton holder ((pendekatan pemuatan malas yang dijelaskan oleh Bill Pugh). Solusi terakhir juga aman untuk benang tanpa memerlukan konstruksi bahasa khusus (mis. Volatile atau disinkronkan).

2
raoadnan

Argumen lain yang sering digunakan terhadap Lajang adalah masalah testabilitas mereka. Lajang tidak mudah dipermainkan untuk tujuan pengujian. Jika ini ternyata menjadi masalah, saya ingin melakukan sedikit modifikasi berikut:

public class SingletonImpl {

    private static SingletonImpl instance;

    public static SingletonImpl getInstance() {
        if (instance == null) {
            instance = new SingletonImpl();
        }
        return instance;
    }

    public static void setInstance(SingletonImpl impl) {
        instance = impl;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

Metode setInstance yang ditambahkan memungkinkan pengaturan implementasi mockup dari kelas singleton selama pengujian:

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

Ini juga bekerja dengan pendekatan inisialisasi awal:

public class SingletonImpl {

    private static final SingletonImpl instance = new SingletonImpl();

    private static SingletonImpl alt;

    public static void setInstance(SingletonImpl inst) {
        alt = inst;
    }

    public static SingletonImpl getInstance() {
        if (alt != null) {
            return alt;
        }
        return instance;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

Ini memiliki kelemahan dalam mengekspos fungsi ini ke aplikasi normal juga. Pengembang lain yang mengerjakan kode itu dapat tergoda untuk menggunakan metode 'setInstance' untuk mengubah fungsi tertentu dan dengan demikian mengubah seluruh perilaku aplikasi, oleh karena itu metode ini harus mengandung setidaknya peringatan yang baik di javadoc itu.

Namun, untuk kemungkinan pengujian-mockup (bila perlu), paparan kode ini mungkin merupakan harga yang dapat diterima untuk membayar.

2
user3792852

kelas singleton paling sederhana

public class Singleton {
  private static Singleton singleInstance = new Singleton();
  private Singleton() {}
  public static Singleton getSingleInstance() {
    return singleInstance;
  }
}
1
rohan kamat

Saya masih berpikir setelah Java 1.5, enum adalah implementasi singleton terbaik yang tersedia karena juga memastikan bahwa bahkan di lingkungan multi-threaded - hanya satu instance dibuat.

public enum Singleton{ INSTANCE; }

dan kamu selesai !!!

0
shikjohari

Lihat posting ini.

Contoh Pola Desain GoF di perpustakaan inti Jawa

Dari bagian "Singleton" jawaban terbaik,

Singleton (dapat dikenali dengan metode kreatif yang mengembalikan contoh yang sama (biasanya dengan sendirinya) setiap kali)

  • Java.lang.Runtime # getRuntime ()
  • Java.awt.Desktop # getDesktop ()
  • Java.lang.System # getSecurityManager ()

Anda juga dapat mempelajari contoh Singleton dari kelas asli Jawa sendiri.

0
phi

Pola singleton terbaik yang pernah saya lihat menggunakan antarmuka Pemasok.

  • Ini generik dan dapat digunakan kembali
  • Ini mendukung inisialisasi malas
  • Ini hanya disinkronkan sampai diinisialisasi, maka pemasok pemblokiran diganti dengan pemasok yang tidak memblokir.

Lihat di bawah:

public class Singleton<T> implements Supplier<T> {

    private boolean initialized;
    private Supplier<T> singletonSupplier;

    public Singleton(T singletonValue) {
        this.singletonSupplier = () -> singletonValue;
    }

    public Singleton(Supplier<T> supplier) {
        this.singletonSupplier = () -> {
            // The initial supplier is temporary; it will be replaced after initialization
            synchronized (supplier) {
                if (!initialized) {
                    T singletonValue = supplier.get();
                    // Now that the singleton value has been initialized,
                    // replace the blocking supplier with a non-blocking supplier
                    singletonSupplier = () -> singletonValue;
                    initialized = true;
                }
                return singletonSupplier.get();
            }
        };
    }

    @Override
    public T get() {
        return singletonSupplier.get();
    }
}
0
user1024314