Model Memori Java dan Pengaturcaraan Serentak: Mendedahkan Misteri Di Sebalik Pengaturcaraan Berbilang Thread

Pengaturcaraan berbilang benang telah menjadi lebih kompleks dan mencabar di Jawa kerana model memori Java. Editor PHP Banana membawakan anda perbincangan mendalam tentang model memori Java dan pengaturcaraan serentak, mendedahkan misteri di sebalik pengaturcaraan berbilang benang. Dalam artikel ini, kami akan meneroka konsep asas model memori Java, memahami prinsip penting dalam pengaturcaraan berbilang benang dan berkongsi beberapa petua praktikal untuk membantu anda memahami dan menggunakan pengaturcaraan serentak dengan lebih baik.

Hubungan berlaku-sebelum mentakrifkan hubungan sebab akibat antara dua peristiwa Jika peristiwa A berlaku-sebelum peristiwa B, maka pengubahsuaian pembolehubah yang dikongsi oleh peristiwa B boleh dilihat oleh peristiwa A. Hubungan berlaku-sebelum terutamanya mempunyai situasi berikut:

1. Peraturan jujukan program: Dalam urutan, pengubahsuaian kepada pembolehubah yang dikongsi oleh penyataan berikutnya kelihatan kepada penyataan sebelumnya.
2. Peraturan Saluran Paip: Jika satu utas menghantar mesej ke utas lain melalui paip (seperti paip atau baris gilir), maka mesej itu boleh dilihat oleh utas penerima.
3. KunciPeraturan: Jika satu utas memperoleh kunci, pengubahsuaian pada pembolehubah kongsi dapat dilihat oleh utas lain.
4. Peraturan pembolehubah tidak menentu: Jika pembolehubah diisytiharkan tidak menentu, pengubahsuaian kepada pembolehubah itu boleh dilihat oleh semua urutan.
5. Peraturan pembolehubah akhir: Jika pembolehubah diisytiharkan muktamad, pengubahsuaian pembolehubah itu boleh dilihat oleh semua urutan.

Selain perhubungan yang berlaku-sebelum, JMM juga mentakrifkan keterlihatan dan keatoman pembolehubah:

1. Keterlihatan: Keterlihatan bermakna pengubahsuaian kepada pembolehubah yang dikongsi oleh satu urutan boleh dilihat oleh urutan lain. JMM memastikan keterlihatan pembolehubah melalui hubungan berlaku-sebelum.
2. Atomicity: Atomicity bermaksud operasi sama ada dilaksanakan sepenuhnya atau tidak dilaksanakan sama sekali. JMM memastikan keatoman pembolehubah melalui kunci dan pembolehubah tidak menentu.

Memahami cara JMM berfungsi adalah penting untuk memahami dan menyelesaikan masalah dalam pengaturcaraan serentak. Dengan memahami hubungan berlaku-sebelum, keterlihatan dan atomicity pembolehubah, anda boleh mengelakkan masalah seperti ketidakkonsistenan data dan kebuntuan dalam pengaturcaraan berbilang benang.

Berikut ialah beberapa contoh kod yang menunjukkan cara JMM berfungsi:

public class VisibilityDemo {

private static boolean visible = false;

public static void main(String[] args) {
new Thread(() -> {
while (!visible) {
// 等待可见性
}
System.out.println("可见性示例：可见");
}).start();

new Thread(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
visible = true;
}).start();
}
}

Dalam contoh ini, dua utas berjalan serentak. Urutan pertama menunggu pembolehubah yang boleh dilihat menjadi benar, manakala urutan kedua ditetapkan kelihatan kepada benar selepas 1 saat. Apabila urutan pertama mengesan bahawa boleh dilihat adalah benar, ia mencetak "Contoh Keterlihatan: Kelihatan".

public class AtomicityDemo {

private static int count = 0;

public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
new Thread(() -> {
synchronized (AtomicityDemo.class) {
count++;
}
}).start();
}

try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("原子性示例：count = " + count);
}
}

Dalam contoh ini, seribu utas berjalan serentak, dan setiap utas menambah kiraan pembolehubah. Memandangkan kiraan ialah pembolehubah yang dikongsi, pengubahsuaian padanya bukan atom, jadi kiraan keluaran akhir mungkin kurang daripada atau lebih daripada 1000.

Atas ialah kandungan terperinci Model Memori Java dan Pengaturcaraan Serentak: Mendedahkan Misteri Di Sebalik Pengaturcaraan Berbilang Thread. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!