Artikel ini menganalisis penggunaan multi-threading yang mudah menguap dan tersinkronisasi di Java beserta contohnya. Bagikan dengan semua orang untuk referensi Anda. Metode implementasi spesifiknya adalah sebagai berikut:
Salin kode sebagai berikut: paket com.chzhao;
Volatiletest kelas publik meluas Thread {
jumlah int statis pribadi = 0;
menjalankan kekosongan publik() {
hitung++;
}
public static void main(String[] args) {
Utas utas[] = Utas baru[10000];
for (int i = 0; i < benang.panjang; i++) {
thread[i] = Volatiletest baru();
}
for (int i = 0; i < benang.panjang; i++) {
benang[i].mulai();
}
mencoba {
Thread.tidur(1000);
} tangkapan (InterruptedException e) {
e.printStackTrace();
}
System.out.println(hitungan);
}
}
Kodenya seperti di atas. Output yang diharapkan adalah 10.000. Namun, karena count++ tidak aman untuk thread, output sering kali kurang dari 10.000.
Untuk mengatasi masalah ini, kata kunci volatil telah ditambahkan.
Salin kode sebagai berikut: paket com.chzhao;
Volatiletest kelas publik meluas Thread {
hitungan int statis volatil pribadi = 0;
menjalankan kekosongan publik() {
hitung++;
}
public static void main(String[] args) {
Utas utas[] = Utas baru[10000];
for (int i = 0; i < benang.panjang; i++) {
thread[i] = Volatiletest baru();
}
for (int i = 0; i < benang.panjang; i++) {
benang[i].mulai();
}
mencoba {
Thread.tidur(2000);
} tangkapan (InterruptedException e) {
e.printStackTrace();
}
System.out.println(hitungan);
}
}
Setelah modifikasi, nilai selain 10.000 sering kali dikeluarkan.
Ubah menjadi bentuk tersinkronisasi, kodenya sebagai berikut:
Salin kode sebagai berikut: paket com.chzhao;
kelas publik SynchronizedTest memperluas Thread {
jumlah int statis pribadi = 0;
menjalankan kekosongan publik() {
disinkronkan (LockClass.lock) {
hitung++;
}
}
public static void main(String[] args) {
Utas utas[] = Utas baru[10000];
for (int i = 0; i < benang.panjang; i++) {
thread[i] = new SynchronizedTest();
}
for (int i = 0; i < benang.panjang; i++) {
benang[i].mulai();
}
mencoba {
Thread.tidur(2000);
} tangkapan (InterruptedException e) {
e.printStackTrace();
}
System.out.println(hitungan);
}
}
Salin kode sebagai berikut: paket com.chzhao;
kelas publik LockClass {
byte statis publik[] kunci = byte baru[0];
}
Setelah modifikasi ini, outputnya adalah 10.000.
Apakah ini berarti kata kunci volatil sama sekali tidak berguna? Hanya sinkronisasi yang dapat menjamin keamanan thread?
menjelaskan:
Bahasa Java berisi dua mekanisme sinkronisasi yang melekat: blok (atau metode) yang disinkronkan dan variabel yang mudah menguap. Kedua mekanisme tersebut diusulkan untuk mencapai keamanan thread kode. Variabel volatil kurang tersinkronisasi (tetapi terkadang lebih sederhana dan lebih murah), dan penggunaannya juga lebih rawan kesalahan. Variabel volatil dalam bahasa Java dapat dianggap sebagai "kurang tersinkronisasi"; dibandingkan dengan blok tersinkronisasi, variabel volatil memerlukan pengkodean lebih sedikit dan memiliki overhead runtime lebih sedikit, namun mereka dapat mencapai Fungsionalitas hanya sebagian dari tersinkronisasi.
Dengan kata lain, dalam beberapa kasus, volitile lebih nyaman digunakan daripada sinkronisasi, tetapi tentu saja sinkronisasinya lebih buruk.
Saya harap artikel ini bermanfaat untuk pemrograman Java semua orang.