Cara Java menggunakan Synchronized untuk mencapai penyegerakan berbilang benang

Sebab untuk menggunakan penyegerakan

1. Berbilang benang mesti digunakan untuk mengakses kelas dalam sistem;

2 Terdapat pembolehubah kelas dalam kelas, atau kaedah dalam kelas Di sana ialah akses kepada sumber awam (seperti membaca dan menulis fail luaran).

Apakah kandungan yang dikunci oleh kunci penyegerakan?

Sama ada anda menambah Disegerakkan sebelum kaedah atau pembolehubah, ia mengunci objek kelas. Setiap objek hanya mempunyai satu kunci yang dikaitkan dengannya.

Contoh berikut menyenaraikan kesan penyegerakan dalam pelbagai situasi

1 Disegerakkan ditambahkan pada kaedah, (kaedah penyegerakan, contoh kelas kunci)

Kod Java

public class Demo1 {             public synchronized void m1(){             //...............         }             public void m2(){             //............                 synchronized(this){                 //.........             }                 //........         }     }

Kesan kedua-dua kaedah penulisan ini adalah sama, dan ia mengunci objek contoh kelas. Jika terdapat objek contoh kelas: demo = Demo1 baru(), dan terdapat dua utas: thread1, thread2, kedua-duanya memanggil objek demo, kemudian, pada masa yang sama, jika thread1 memanggil demo.m1(), maka thread2 ialah dalam demo.m1() dan demo.m2() tidak boleh diakses pada masa itu kerana thread1 menggunakan kunci objek demo, ia tidak boleh diperuntukkan kepada thread lain untuk digunakan

Walau bagaimanapun, jika thread1 memanggil demo1.m1() , thread2 boleh memanggil demo2.m1() pada masa yang sama, kerana mereka memanggil contoh objek kelas Demo1 yang berbeza.

2. Disegerakkan ditambahkan pada pembolehubah, (blok disegerakkan, contoh kelas kunci)

Kod Java

public class Demo2 {         Object a = new Object();         Object b = new Object();             public void m1(){             //............                 synchronized(a){                 //.........             }                 //........         }             public void m2(){             //............                 synchronized(b){                 //.........             }                 //........         }     }

Dalam kes ini, ia adalah mengunci blok kod, objek yang dikunci ialah pembolehubah a atau b; (perhatikan bahawa a dan b bukan statik) Jika terdapat objek contoh kelas: demo = new Demo2(), dan terdapat dua utas lain: thread1, thread2 , kedua-duanya dipanggil objek demo, maka, pada masa yang sama, jika thread1 memanggil demo.m1(), thread2 boleh mengakses demo.m2() dalam masa itu tetapi tidak boleh mengakses blok penyegerakan demo.m1(), kerana a disekat oleh benang1 Dikunci.

3. Pembolehubah kelas kunci disegerakkan, iaitu pembolehubah statik (mungkin atribut, mungkin kaedah) (mengunci objek kelas)

Kod Java

public class Demo3 {         static Object o = new Object();             public static synchronized void m1() {             //....         }             public static void m2() {             //...             synchronized (Demo3.class) {                 //.....             }             //.....         }             public static void m3() {             //..........             try {                 synchronized (Class.forName("Demo3")) {                   //............                 }             } catch (ClassNotFoundException ex) {             }             //.............         }             public static void m4() {             //............            synchronized(o){              //........            }             //..........         }     }

Kesan yang dicapai oleh empat kaedah di atas adalah sama Objek yang mereka kunci adalah semua kelas Demo3, bukan objek contoh kelas, iaitu, dalam pelbagai utas, sumber yang dikongsi adalah milik kelas, bukan objek . Dalam kes ini, jika thread1 mengakses mana-mana daripada empat kaedah ini, tiada thread lain boleh mengakses empat kaedah ini pada masa yang sama.

4. Kaedah kelas mengakses sumber yang biasa kepada berbilang rangkaian, dan sumber itu berubah-ubah Dalam kes ini, penyegerakan juga diperlukan

Kod Java

public class Demo4 {         static String path = "file path";             public void readConfiFile() {             synchronized (path) {                // 读取该path指定的文件。             }             }             public void writeConfiFile() {             synchronized (path) {                 //写信息到该path指定的文件。             }         }     }

Dalam kes ini, ia mesti dikunci sebagai pembolehubah kelas dan bukannya objek contoh kelas, kerana ini ialah jenis perkongsian sumber kelas pembolehubah, bukan perkongsian sumber objek contoh kelas.

Benang mempunyai cara kejayaan dan kegagalan mereka sendiri, jika ia digunakan dengan baik, ia boleh meningkatkan prestasi, tetapi jika ia tidak digunakan dengan baik, ia akan menyebabkan masalah yang tidak berkesudahan untuk sistem.

PS: Penyegerakan benang memerlukan banyak overhed sistem, jadi apabila menggunakannya, jika tidak perlu, cuba jangan gunakan fungsi penyegerakan.

Atas ialah kandungan terperinci Cara Java menggunakan Synchronized untuk mencapai penyegerakan berbilang benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!