Artikel ini membagikan 4 contoh penjelasan terperinci tentang sinkronisasi
1. Apakah akan menambahkan kata kunci yang disinkronkan
Public Class ThreadTest {public static void main (string [] args) {contoh contoh = contoh baru (); Thread t1 = utas baru (contoh); Thread t2 = utas baru1 (contoh); t1.start (); t2.start (); }} Contoh kelas {public disinkronkan void whous () {for (int i = 0; i <5; ++ i) {coba {thread.sleep (1000); } catch (InterruptedException e) {E.PrintStackTrace (); } System.out.println ("Excute:" + i); }}} class thread1 memperluas thread {contoh private; thread publik1 (contoh contoh) {this.example = contoh; } @Override public void run () {example.excute (); }}Hasil output dari kata kunci yang disinkronkan adalah sebagai berikut
Satu set 0-4 akan menjadi output terlebih dahulu, dan kemudian set berikutnya akan menjadi output, dan kedua utas akan dieksekusi secara berurutan.
Eksute: 0
Eksute: 1
Eksute: 2
Eksute: 3
Eksute: 4
Eksute: 0
Eksute: 1
Eksute: 2
Eksute: 3
Eksute: 4
Hasil output dari kata kunci yang disinkronkan adalah sebagai berikut
Dua utas mengeksekusi metode ekskute secara bersamaan dan bersamaan
Eksute: 0
Eksute: 0
Eksute: 1
Eksute: 1
Eksute: 2
Eksute: 2
Eksute: 3
Eksute: 3
Eksute: 4
Eksute: 4
2. Situasi multi-threading dari berbagai metode
Public Class ThreadTest {public static void main (string [] args) {contoh contoh = contoh baru (); Thread t1 = utas baru (contoh); Thread t2 = new thread2 (contoh); t1.start (); t2.start (); }} Contoh kelas {public disinkronkan void whous () {for (int i = 0; i <5; ++ i) {coba {thread.sleep (1000); } catch (InterruptedException e) {E.PrintStackTrace (); } System.out.println ("Excute:" + i); }} public yang disinkronkan void whoUT1 () {for (int i = 0; i <5; ++ i) {coba {thread.sleep (1000); } catch (InterruptedException e) {E.PrintStackTrace (); } System.out.println ("Excute1:" + i); }}} class thread1 memperluas thread {contoh private; thread publik1 (contoh contoh) {this.example = contoh; } @Override public void run () {example.excute (); }} class thread2 memperluas thread {contoh private contoh; thread publik2 (contoh contoh) {this.example = contoh; } @Override public void run () {example.excute1 (); }}Hasil eksekusi adalah sebagai berikut
Hal yang sama dijalankan secara berurutan, dan satu utas dieksekusi sebelum utas lain dieksekusi.
Eksute: 0
Eksute: 1
Eksute: 2
Eksute: 3
Eksute: 4
Excute1: 0
Excute1: 1
Excute1: 2
Excute1: 3
Eksklusif1: 4
Jika kata kunci yang disinkronkan dihapus, kedua metode tersebut dieksekusi secara bersamaan dan tidak memiliki pengaruh timbal balik.
Tetapi seperti yang tertulis dalam contoh subrutin, bahkan dua metode:
Hasil eksekusi selalu merupakan output dari satu utas dan kemudian eksekusi utas lain.
menjelaskan:
Jika suatu objek memiliki beberapa metode yang disinkronkan, dan utas telah memasukkan metode yang disinkronkan pada saat tertentu, maka utas lain tidak dapat mengakses metode objek yang disinkronkan sebelum metode dijalankan.
Kesimpulan:
Ketika kata kunci yang disinkronkan memodifikasi metode, metode ini disebut metode sinkronisasi.
Setiap objek di Java memiliki kunci, atau monitor. Ketika utas mengakses metode sinkronisasi suatu objek, objek terkunci, dan tidak ada utas lain yang dapat mengakses metode objek yang disinkronkan (di sini mengacu pada semua metode sinkronisasi, bukan hanya metode yang sama). Tidak sampai utas sebelumnya melengkapi metode eksekusi (atau melempar pengecualian), kunci objek dilepaskan, sehingga utas lain dapat mengakses metode yang disinkronkan dari objek lagi.
Perhatikan bahwa objek terkunci saat ini. Jika itu adalah objek yang berbeda, tidak ada hubungan pembatasan antara objek.
Saat mencoba membangun objek utas kedua dalam kode, objek contoh baru dilewatkan, maka tidak ada batasan antara eksekusi kedua utas tersebut.
3. Metode Sinkronisasi Statis
Ketika metode yang dimodifikasi kata kunci yang disinkronkan juga dimodifikasi oleh statis, telah dikatakan sebelumnya bahwa metode sinkronisasi non-statis akan mengunci objek, tetapi metode statis bukan milik objek, tetapi kelas, dan akan mengunci objek kelas kelas di mana metode ini berada.
Public Class ThreadTest {public static void main (string [] args) {contoh contoh = contoh baru (); Contoh contoh2 = contoh baru (); Thread t1 = utas baru (contoh); Thread t2 = thread2 baru (contoh2); t1.start (); t2.start (); }} Contoh kelas {public static void whoid () {for (int i = 0; i <5; ++ i) {coba {thread.sleep (1000); } catch (InterruptedException e) {E.PrintStackTrace (); } System.out.println ("Excute:" + i); }} public static void whoid1 () {for (int i = 0; i <5; ++ i) {coba {thread.sleep (1000); } catch (InterruptedException e) {E.PrintStackTrace (); } System.out.println ("Excute1:" + i); }}} class thread1 memperluas thread {contoh private; thread publik1 (contoh contoh) {this.example = contoh; } @Override public void run () {example.excute (); }} class thread2 memperluas thread {contoh private contoh; thread publik2 (contoh contoh) {this.example = contoh; } @Override public void run () {example.excute1 (); }}Hasil eksekusi adalah sebagai berikut
Eksute: 0
Eksute: 1
Eksute: 2
Eksute: 3
Eksute: 4
Excute1: 0
Excute1: 1
Excute1: 2
Excute1: 3
Eksklusif1: 4
Jika tidak ada pengubah statis, dan dua utas melewati objek yang berbeda, mereka akan dieksekusi secara bersamaan pada saat yang sama.
Jadi jika itu adalah metode statis (execute () dan execute2 () keduanya memiliki kata kunci statis yang ditambahkan), bahkan jika objek contoh yang berbeda diteruskan ke dua utas, kedua utas tersebut masih dibatasi satu sama lain. Seseorang harus dieksekusi terlebih dahulu dan kemudian yang berikutnya.
Kesimpulan:
Jika metode yang disinkronkan adalah statis, ketika utas mengakses metode, tidak mengunci objek di mana metode yang disinkronkan berada, tetapi objek kelas yang sesuai dengan kelas di mana metode yang disinkronkan berada. Di Java, tidak peduli berapa banyak objek yang dimiliki kelas, objek ini akan sesuai dengan objek kelas yang unik. Oleh karena itu, ketika utas mengakses dua metode statis dan disinkronkan dari dua objek dari kelas yang sama, urutan eksekusi mereka juga berurutan, yaitu, satu utas menjalankan metode terlebih dahulu, dan utas lainnya dimulai setelah eksekusi selesai.
4. Blok yang disinkronkan
disinkronkan (objek)
{
}
Ini berarti bahwa utas akan mengunci objek objek saat dieksekusi. (Perhatikan bahwa objek ini dapat menjadi objek dari kelas apa pun, atau Anda dapat menggunakan kata kunci ini).
Dengan cara ini, Anda dapat menentukan objek yang terkunci sendiri.
Public Class ThreadTest {public static void main (string [] args) {contoh contoh = contoh baru (); Thread t1 = utas baru (contoh); Thread t2 = new thread2 (contoh); t1.start (); t2.start (); }} Contoh kelas {public void whous () {disinkronkan (this) {for (int i = 0; i <5; ++ i) {coba {thread.sleep (1000); } catch (InterruptedException e) {E.PrintStackTrace (); } System.out.println ("Excute:" + i); }}} public void knalpot1 () {disinkronkan (this) {for (int i = 0; i <5; ++ i) {coba {thread.sleep (1000); } catch (InterruptedException e) {E.PrintStackTrace (); } System.out.println ("Excute1:" + i); }}}}}} class thread1 memperluas thread {contoh private contoh; thread publik1 (contoh contoh) {this.example = contoh; } @Override public void run () {example.excute (); }} class thread2 memperluas thread {contoh private contoh; thread publik2 (contoh contoh) {this.example = contoh; } @Override public void run () {example.excute1 (); }}Hasil eksekusi adalah sebagai berikut
Eksute: 0
Eksute: 1
Eksute: 2
Eksute: 3
Eksute: 4
Excute1: 0
Excute1: 1
Excute1: 2
Excute1: 3
Eksklusif1: 4
Efek yang dicapai dengan contoh program 4 sama dengan contoh program 2. Kedua utas dieksekusi secara berurutan, bukan secara bersamaan. Ketika satu utas dieksekusi, objek objek terkunci, dan utas lainnya tidak dapat menjalankan blok yang sesuai.
Metode yang disinkronkan sebenarnya setara dengan membungkus semua pernyataan dalam metode ini dengan blok yang disinkronkan, dan kemudian melewati kata kunci ini dalam tanda kurung blok yang disinkronkan. Tentu saja, jika itu adalah metode statis, objek kelas perlu dikunci.
Mungkin hanya beberapa baris kode dalam suatu metode yang akan melibatkan masalah sinkronisasi utas, sehingga blok yang disinkronkan mengontrol akses beberapa utas lebih granular daripada metode yang disinkronkan. Hanya konten dalam blok yang disinkronkan yang tidak dapat diakses oleh beberapa utas secara bersamaan, dan pernyataan lain dalam metode ini masih dapat diakses oleh beberapa utas secara bersamaan (termasuk sebelum dan sesudah blok yang disinkronkan).
Kesimpulan:
Metode yang disinkronkan adalah kontrol bersamaan berbutir kasar. Pada saat tertentu, hanya satu utas yang dapat menjalankan metode yang disinkronkan;
Blok yang disinkronkan adalah kontrol konkurensi berbutir halus, yang hanya menyinkronkan kode di blok. Kode lain yang terletak di metode dan selain blok yang disinkronkan dapat diakses oleh beberapa utas secara bersamaan.
Di atas adalah tentang metode sinkronisasi blok yang disinkronkan dari pemrograman multi-threaded Java. Saya berharap ini akan membantu untuk pembelajaran semua orang.