Penyegerakan benang Java dan pengecualian bersama: bermula dari awal, mencipta program serentak yang cekap

Penyegerakan benang Java dan pengecualian bersama adalah kunci untuk menulis program serentak yang cekap. Editor PHP Banana akan membawa anda dari awal untuk meneroka mekanisme penyegerakan benang dalam Java, membolehkan anda mencipta program serentak yang cekap dan stabil serta meningkatkan kualiti dan prestasi kod.

JavaBenangTinjauan Keseluruhan Penyegerakan dan Pengecualian Bersama

Di Java, penyegerakan rangkaian dan pengecualian bersama adalah teknik untuk memastikan tiada perlumbaan data atau ketidakkonsistenan lain berlaku apabila berbilang rangkaian berkongsi data. Penyegerakan benang bermakna apabila berbilang benang mengakses data kongsi, mereka menyelaraskan akses mereka melalui beberapa mekanisme untuk memastikan ketekalan dan integriti data. Pengecualian bersama utas bermakna hanya satu utas boleh mengakses data kongsi dan utas lain hanya boleh menunggu.

Mekanisme penyegerakan benang Java

Pelbagai mekanisme penyegerakan benang disediakan di Java, yang paling biasa ialah kunci dan monitor. Kunci ialah mekanisme penyegerakan peringkat rendah yang membolehkan benang memperoleh kunci sebelum memasuki bahagian kritikal (iaitu, blok kod tempat data kongsi terletak) dan lepaskan kunci selepas keluar dari bahagian kritikal. Monitor ialah mekanisme penyegerakan lanjutan yang menggabungkan kunci dan pembolehubah keadaan supaya benang boleh tidur sementara menunggu kunci sehingga kunci dilepaskan.

Contoh penyegerakan benang Java

Untuk lebih memahami penyegerakan benang Java dan pengecualian bersama, mari lihat contoh kod mudah. Dalam contoh ini, kita mempunyai dua utas yang mengakses pembolehubah yang dikongsi secara serentak. Jika tiada penyegerakan benang, kemungkinan besar dua utas akan mengubah suai pembolehubah yang dikongsi pada masa yang sama, mengakibatkan ketidakkonsistenan data.

public class SimpleSyncDemo {
private int sharedVariable = 0;

public void incrementSharedVariable() {
sharedVariable++;
}

public static void main(String[] args) {
SimpleSyncDemo demo = new SimpleSyncDemo();

Thread thread1 = new Thread(() -> {
for (int i = 0; i < 100000; i++) {
demo.incrementSharedVariable();
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 100000; i++) {
demo.incrementSharedVariable();
}
});

thread1.start();
thread2.start();

try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Shared variable value: " + demo.sharedVariable);
}
}

Dalam contoh ini, kami menggunakan kunci untuk menyegerakkan pembolehubah kongsi. Kami mula-mula mencipta objek kunci, kemudian dalam setiap utas, kami memperoleh kunci sebelum memasuki bahagian kritikal dan lepaskan kunci selepas keluar dari bahagian kritikal. Dengan cara ini, kami memastikan bahawa hanya satu urutan boleh mengakses pembolehubah yang dikongsi, sekali gus mengelakkan isu perlumbaan data.

Mekanisme pengecualian bersama benang Java

Pengecualian bersama utas Java bermakna hanya satu utas boleh mengakses data kongsi dan utas lain hanya boleh menunggu. Cara paling mudah untuk melaksanakan pengecualian bersama benang ialah menggunakan kunci mutex (Mutex). Mutex ialah jenis kunci khas yang hanya membenarkan satu utas memperoleh kunci, dan utas lain hanya boleh menunggu kunci dilepaskan.

contoh pengecualian bersama benang Java

Untuk lebih memahami Java thread mutex, mari lihat contoh kod mudah. Dalam contoh ini, kita mempunyai dua utas yang mengakses pembolehubah yang dikongsi secara serentak. Jika tidak ada pengecualian bersama benang, kemungkinan besar dua utas akan mengubah suai pembolehubah yang dikongsi pada masa yang sama, mengakibatkan ketidakkonsistenan data.

public class SimpleMutexDemo {
private final Object lock = new Object();
private int sharedVariable = 0;

public void incrementSharedVariable() {
synchronized (lock) {
sharedVariable++;
}
}

public static void main(String[] args) {
SimpleMutexDemo demo = new SimpleMutexDemo();

Thread thread1 = new Thread(() -> {
for (int i = 0; i < 100000; i++) {
demo.incrementSharedVariable();
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 100000; i++) {
demo.incrementSharedVariable();
}
});

thread1.start();
thread2.start();

try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Shared variable value: " + demo.sharedVariable);
}
}

Dalam contoh ini, kami menggunakan kunci mutex untuk mencapai pengecualian bersama benang. Kami mula-mula mencipta objek mutex, kemudian dalam setiap benang, kami memperoleh mutex sebelum memasuki bahagian kritikal dan melepaskan mutex selepas keluar dari bahagian kritikal. Dengan cara ini, kami memastikan bahawa hanya satu urutan boleh mengakses pembolehubah yang dikongsi, sekali gus mengelakkan masalah perlumbaan data.

Kesimpulan

Penyegerakan benang dan pengecualian bersama adalah pengetahuan asas yang penting dalam JavaPengaturcaraan serentak. Menguasai teknologi ini boleh membantu kami menulis program concurrency yang cekap dan boleh dipercayai. Dalam artikel ini, kami memperkenalkan asas penyegerakan benang Java dan pengecualian bersama, dan menunjukkan melalui contoh kod cara menggunakan teknik ini untuk menulis atur cara serentak.

Atas ialah kandungan terperinci Penyegerakan benang Java dan pengecualian bersama: bermula dari awal, mencipta program serentak yang cekap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!