Menyahmisti Model Memori Java: Menguasai Rahsia Di Sebalik Pengaturcaraan Berbilang Benang

editor php Yuzai membawa anda mendedahkan model memori Java dan memperoleh pemahaman mendalam tentang misteri di sebalik pengaturcaraan berbilang benang. Pengaturcaraan berbilang benang ialah kemahiran penting dalam pembangunan Java, dan memahami model memori adalah penting untuk menulis program berbilang benang yang cekap dan boleh dipercayai. Mari kita terokai model memori Java bersama-sama dan bongkar misteri pengaturcaraan berbilang benang!

Matlamat utama JMM adalah untuk memastikan ketepatan dan kebolehramalan program berbilang benang . Ia menghalang perlumbaan data dan isu konsistensi memori dengan mentakrifkan satu set peraturan untuk mengawal selia capaian benang kepada memori yang dikongsi. Prinsip asas JMM termasuk:

• Keterlihatan: Pengubahsuaian pembolehubah yang dikongsi mengikut urutan mesti ditunjukkan dalam julat yang boleh dilihat pada urutan lain tepat pada masanya.
• Atomicity: Operasi baca dan tulis pada pembolehubah yang dikongsi adalah atom, iaitu, tidak boleh terganggu.
• Pemesanan: Susunan urutan mengakses pembolehubah kongsi mesti konsisten dengan susunan pelaksanaan dalam program.

Untuk mencapai prinsip asas ini, JMM memperkenalkan konsep utama berikut:

• Memori utama: Memori utama ialah ruang memori fizikal yang dikongsi oleh semua benang.
• Memori kerja: Setiap utas mempunyai ingatan kerjanya sendiri, yang menyimpan salinan pembolehubah peribadi utas itu.
• Protokol koheren cache: CacheProtokol koheren ialah protokol yang digunakan untuk memastikan data dalam berbilang cache pemproses kekal konsisten.

Apabila benang mengubah suai pembolehubah yang dikongsi, ia menulis nilai yang diubah suai ke memori utama. Benang lain boleh mendapatkan nilai terkini dengan membaca nilai dalam ingatan utama. Walau bagaimanapun, disebabkan kependaman protokol koheren cache, urutan lain mungkin tidak melihat nilai yang diubah suai dengan serta-merta. Untuk menyelesaikan masalah ini, JMM memperkenalkan konsep penghalang ingatan. Halangan memori memaksa benang untuk segera menulis nilai yang diubah suai ke memori utama dan memastikan bahawa benang lain dapat melihat nilai yang diubah suai.

Bahasa Java menyediakan kata kunci synchronized 和 volatile 两个关键字来实现线程同步和可见性。synchronized 关键字可以保证对共享变量的访问是原子的，volatile untuk memastikan pengubahsuaian kepada pembolehubah yang dikongsi dapat dilihat.

Berikut ialah beberapa kod demo yang menunjukkan cara menggunakan kata kunci synchronized 和 volatile untuk mencapai penyegerakan dan keterlihatan benang:

class SharedCounter {
private int count = 0;

public synchronized void increment() {
count++;
}

public int getCount() {
return count;
}
}

public class Main {
public static void main(String[] args) {
SharedCounter counter = new SharedCounter();

Thread thread1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});

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

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

System.out.println("Final count: " + counter.getCount());
}
}

Dalam contoh ini, kami menggunakan synchronized 关键字来保证对 count akses kepada pembolehubah menjadi atom, sekali gus mengelakkan isu perlumbaan data.

class SharedCounter {
private volatile int count = 0;

public void increment() {
count++;
}

public int getCount() {
return count;
}
}

public class Main {
public static void main(String[] args) {
SharedCounter counter = new SharedCounter();

Thread thread1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
System.out.println("Current count: " + counter.getCount());
}
});

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

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

Dalam contoh ini, kami menggunakan volatile 关键字来保证对 count 变量的修改是可见的，从而使线程 2 能够及时地看到线程 1 对 count pengubahsuaian pembolehubah.

Pemahaman mendalam tentang model memori Java adalah penting untuk menyelesaikan masalah dalam pengaturcaraan serentak. Dengan menguasai prinsip asas dan konsep utama JMM, pengaturcara boleh menulis program berbilang benang yang lebih mantap dan boleh diramal.

Atas ialah kandungan terperinci Menyahmisti Model Memori Java: Menguasai Rahsia Di Sebalik Pengaturcaraan Berbilang Benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!