Pola Desain: Singleton

Hello! Dina iki kita bakal ngerti kanthi rinci pola desain sing beda-beda, lan kita bakal miwiti pola Singleton, sing uga disebut "singleton". Ayo elinga: apa sing kita ngerti babagan pola desain ing umum? Pola desain minangka praktik paling apik sing bisa ditindakake kanggo ngrampungake sawetara masalah sing dikenal. Pola desain umume ora ana gandhengane karo basa pamrograman. Njupuk wong minangka pesawat saka Rekomendasi, ing ngisor iki sing bisa supaya kesalahane lan ora reinvent Panjenengan wheel .

Apa sing singleton?

Singleton minangka salah sawijining pola desain paling gampang sing bisa ditrapake ing kelas. Kadhangkala wong ngomong "kelas iki minangka singleton," tegese kelas iki ngetrapake pola desain singleton. Kadhangkala perlu kanggo nulis kelas sing mung siji obyek bisa digawe. Contone, kelas sing tanggung jawab kanggo ngangkut barang utawa nyambung menyang database. Pola desain Singleton nggambarake carane kita bisa ngrampungake tugas kasebut. Singleton minangka pola desain sing nindakake rong perkara:

1. Nyedhiyakake jaminan yen kelas mung duwe siji conto kelas.

2. Nyedhiyani titik akses global kanggo conto kelas iki.

Mula, ana rong fitur sing dadi karakteristik meh saben implementasine pola singleton:

1. Konstruktor pribadi. Watesan kemampuan kanggo nggawe obyek kelas ing njaba kelas dhewe.

2. Cara statis umum sing ngasilake conto kelas. Cara iki diarani getInstance. Iki minangka titik akses global kanggo conto kelas.

Pilihan implementasine

Pola desain singleton digunakake kanthi cara sing beda-beda. Saben pilihan apik lan ala kanthi cara dhewe. Ing kene, kaya biasane: ora ana sing cocog, nanging sampeyan kudu ngupayakake. Nanging pisanan, ayo nemtokake apa sing apik lan sing ala, lan metrik apa sing mengaruhi evaluasi implementasine pola desain. Ayo dadi miwiti karo positif. Ing ngisor iki kritéria sing menehi juiciness lan daya tarik implementasine:

• Initialization kesed: nalika kelas dimuat nalika aplikasi mlaku persis nalika dibutuhake.

• Kesederhanaan lan transparansi kode: metrik, mesthi, subyektif, nanging penting.

• Safety thread: bisa digunakake kanthi bener ing lingkungan multi-threaded.

• Kinerja dhuwur ing lingkungan multi-Utas: Utas mblokir saben liyane minimal utawa ora kabeh nalika nuduhake sumber daya.

Saiki cons. Ayo dhaptar kritéria sing nuduhake implementasine ing cahya sing ala:

• Inisialisasi non-lazy: nalika kelas dimuat nalika aplikasi diwiwiti, preduli saka apa sing dibutuhake utawa ora (paradoks, ing jagad IT luwih becik kesed)

• Kerumitan lan keterbacaan kode sing ora apik. Metrik uga subyektif. Kita bakal nganggep yen getih teka saka mripat, implementasine kaya-kaya.

• Lack saka safety thread. Ing tembung liyane, "bebaya thread". Operasi sing salah ing lingkungan multi-threaded.

• Kinerja sing ora apik ing lingkungan multi-utas: benang mblokir saben liyane utawa asring nalika nuduhake sumber daya.

Kode

Saiki kita siyap nimbang macem-macem opsi implementasine, nyathet pro lan kontra:

Solusi prasaja

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

    private Singleton() {
    }

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

Implementasine paling gampang. Kaluwihan:

• Kesederhanaan lan transparansi kode

• Keamanan thread

• Kinerja dhuwur ing lingkungan multi-threaded

Minus:

• Ora kesed initialization.

Ing upaya kanggo mbenerake cacat pungkasan, kita entuk implementasine nomer loro:

Inisialisasi Lazy

public class Singleton {
  private static Singleton INSTANCE;

  private Singleton() {}

  public static Singleton getInstance() {
    if (INSTANCE == null) {
      INSTANCE = new Singleton();
    }
    return INSTANCE;
  }
}

Kaluwihan:

• Inisialisasi malas.

Minus:

• Ora aman thread

Implementasine menarik. Kita bisa initialize lazily, nanging kita wis ilang safety thread. Ora masalah: ing implementasine nomer telu kita nyinkronake kabeh.

Aksesor sing disinkronake

public class Singleton {
  private static Singleton INSTANCE;

  private Singleton() {
  }

  public static synchronized Singleton getInstance() {
    if (INSTANCE == null) {
      INSTANCE = new Singleton();
    }
    return INSTANCE;
  }
}

Kaluwihan:

• Inisialisasi malas.

• Keamanan thread

Minus:

• Kinerja sing kurang apik ing lingkungan multi-threaded

apik tenan! Ing implementasine nomer telu, kita nggawa bali safety thread! Bener, alon ... Saiki cara kasebut getInstancedisinkronake, lan sampeyan mung bisa ngetik siji-sijine. Ing kasunyatan, kita ora perlu kanggo nyinkronake kabeh cara, nanging mung bagean kasebut ing ngendi kita miwiti obyek kelas anyar. Nanging kita ora bisa mung mbungkus synchronizedbagean sing tanggung jawab kanggo nggawe obyek anyar ing blok: iki ora bakal nyedhiyakake safety thread. Iku rada rumit. Cara sinkronisasi sing bener diwenehi ing ngisor iki:

Dobel Dipriksa Ngunci

public class Singleton {
    private static Singleton INSTANCE;

  private Singleton() {
  }

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

Kaluwihan:

• Inisialisasi malas.

• Keamanan thread

• Kinerja dhuwur ing lingkungan multi-threaded

Minus:

• Ora didhukung ing versi Java sing luwih murah tinimbang 1.5 (tembung kunci sing ora stabil didandani ing versi 1.5)

Aku nyathet yen opsi implementasine iki bisa digunakake kanthi bener, siji saka rong kondisi dibutuhake. Variabel INSTANCEkudu salah siji final, utawa volatile. Implementasi pungkasan sing bakal kita bahas dina iki yaiku Class Holder Singleton.

Pemegang Kelas Singleton

public class Singleton {

   private Singleton() {
   }

   private static class SingletonHolder {
       public static final Singleton HOLDER_INSTANCE = new Singleton();
   }

   public static Singleton getInstance() {
       return SingletonHolder.HOLDER_INSTANCE;
   }
}

Kaluwihan:

• Inisialisasi malas.

• Keamanan thread.

• Kinerja dhuwur ing lingkungan multi-threaded.

Minus:

• Kanggo operasi sing bener, perlu kanggo njamin yen obyek kelas Singletondiinisialisasi tanpa kesalahan. Yen ora, telpon cara pisanan getInstancebakal mungkasi kesalahan ExceptionInInitializerError, lan kabeh sing sakteruse bakal gagal NoClassDefFoundError.

Implementasine meh sampurna. Lan kesed, lan thread-aman, lan cepet. Nanging ana nuansa sing diterangake ing minus. Tabel perbandingan saka macem-macem implementasi pola Singleton:

Pros lan cons saka pola Singleton

Umumé, singleton nindakake apa sing dikarepake:

1. Nyedhiyakake jaminan yen kelas mung duwe siji conto kelas.

2. Nyedhiyani titik akses global kanggo conto kelas iki.

Nanging, pola iki duwe kekurangan:

1. Singleton nglanggar SRP (Prinsip Tanggung Jawab Tunggal) - kelas Singleton, saliyane tanggung jawab langsung, uga ngontrol jumlah salinan.

2. Ketergantungan kelas utawa cara biasa ing singleton ora katon ing kontrak umum kelas kasebut.

3. Variabel global ala. Singleton pungkasane dadi siji variabel global sing akeh banget.

4. Ing ngarsane singleton nyuda testability saka aplikasi ing umum lan kelas sing nggunakake singleton ing tartamtu.

OK iku kabeh wis rampung Saiki. Kita nyawang pola desain singleton. Saiki, ing obrolan kanggo urip karo kanca-kanca programmer, sampeyan bakal bisa ngomong ora mung apa sing apik babagan iki, nanging uga sawetara tembung babagan apa sing ala. Good luck ing nguwasani kawruh anyar.

Wacan tambahan:

• Nggunakake Pola Singleton
• Singleton sing bener ing Jawa
• Singleton "On Demand Holder idiom"
• Cara Efektif kanggo Ngleksanakake lan Gunakake Pola Desain Singleton
• Praktik Paling Apik Pola Desain Tunggal Jawa kanthi Tuladha