Pertama, tulis satu kasus:
kelas publik singledemo {private static singledemo s = null; private singledemo () {} public static singledemo getInstance () {if (s == null) {s = new singledemo (); } return s; }}Tulis kelas tes:
Public Class ThreadDemo3 {public static void main (string [] args) {singledemo s1 = singledemo.getInstance (); Singledemo s2 = singledemo.getInstance (); System.out.println (S2 == S2); }}Hasil berjalan selalu benar, yang berarti tidak ada masalah di bawah satu utas. Mari kita tulis multi-thread untuk mengakses kasus tunggal.
Public Class ThreadTest mengimplementasikan runnable {// menyimpan objek singleton, menggunakan set adalah untuk tidak menyimpan elemen duplikat set publik <singledemo> singles = hashset baru <singledemo> (); @Override public void run () {// dapatkan singledemo s = singledemo.getInstance (); // menambahkan singleton singles.add (s); }}Gunakan akses bersamaan multithreaded ke singleton:
Public Class ThreadDemo3 {public static void main (string [] args) {// singledemo s1 = singledemo.getInstance (); // singledemo s2 = singledemo.getInstance (); // System.out.println (S2 == S2); Threadtest t = threadTest baru (); utas baru (t) .start (); utas baru (t) .start (); utas baru (t) .start (); utas baru (t) .start (); utas baru (t) .start (); utas baru (t) .start (); utas baru (t) .start (); utas baru (t) .start (); utas baru (t) .start (); System.out.println (T.Singles); }}
Hasil operasi adalah sebagai berikut:
[com.persagy.thread.singledemo@1bc4459, com.persagy.thread.singledemo@150bd4d]
atau
[com.persagy.thread.singledemo@12b6651]
Itu berarti bahwa ada masalah keamanan akses concurrent yang berulir, dan instance yang diperoleh mungkin tidak sama
Bagaimana cara menyelesaikan masalah keamanan utas?
Tentu saja, mekanisme kunci sinkronisasi digunakan.
Berikut ini adalah peningkatan singleton:
kelas publik singledemo {private static singledemo s = null; private singledemo () {} public static Synrchronized singledemo getInstance () {if (s == null) {s = singledemo baru ();} return s;}} Masalah keamanan utas diselesaikan setelah menambahkan fungsi sinkron
Jalankan beberapa kali untuk mendapatkan contoh yang sama, dan tidak akan ada contoh 2.
[com.persagy.thread.singledemo@12b6651]
Namun, dalam kasus akses bersamaan multi-utas, setiap utas harus menilai kunci setiap kali memperoleh sebuah instance, yang merupakan efisiensi yang relatif rendah. Untuk meningkatkan efisiensi, saya menambahkan metode penilaian ganda untuk menyelesaikan masalah efisiensi
Kodenya adalah sebagai berikut:
Public Class singledemo {private static singledemo s = null; private singledemo () {} public static singledemo getInstance () {/ * Jika utas pertama memperoleh objek instance dari singleton, * ketika utas berikutnya memperoleh contoh, ia tidak perlu memasukkan blok kode sinkronisasi sinkronisasi. */if (s == null) {// kunci yang digunakan dalam blok kode sinkronisasi adalah objek file bytecode singleton, dan kunci ini hanya dapat digunakan disinkronkan (singledemo.class) {if (s == null) {s = singledemo baru ();}}}}}}} {s = singledemo ();}}}}}}} {s = singledemo ();}}}}}} {s = singledemo ();Metode ini memecahkan masalah keamanan utas orang malas dan meningkatkan efisiensi. Namun, dalam perkembangan aktual, lebih banyak orang menggunakan orang yang lapar. Bagaimanapun, kode ini lebih rumit dan rumit.
Di atas adalah konten lengkap dari solusi sempurna untuk masalah keamanan utas malas dalam mode desain kasus tunggal yang dibawa editor kepada Anda. Saya harap semua orang akan mendukung wulin.com lebih banyak ~