Peranan dan penggunaan kata kunci yang tidak menentu dalam pengaturcaraan selari Java

Dalam pengaturcaraan selari Java, kata kunci yang tidak menentu memastikan akses yang konsisten kepada pembolehubah dikongsi dalam persekitaran berbilang benang: mengisytiharkan pembolehubah tidak menentu untuk menghalang pemproses daripada menyusun semula pengoptimuman. Pastikan semua urutan mengakses pembolehubah yang dikongsi dengan cara yang konsisten untuk mengelakkan ketidakkonsistenan. Kod sampel menunjukkan penggunaan kata kunci yang tidak menentu untuk mengira pembilang dengan betul dalam persekitaran berbilang benang.

Peranan dan penggunaan kata kunci yang tidak menentu dalam pengaturcaraan selari Java

Pengenalan

kata kuncivolatile adalah sangat penting dalam pengaturcaraan selari Java, ia digunakan untuk memastikan bahawa threading Akses pembolehubah yang dikongsi dengan betul dalam persekitaran. Ia melakukan ini dengan menghalang pemproses daripada melakukan pengoptimuman penyusunan semula pada pembolehubah yang dikongsi. volatile 关键词在 Java 并行编程中非常重要，它用于确保在多线程环境下正确地访问共享变量。它通过阻止处理器针对共享变量执行重排序优化来实现这一目标。

作用

volatile 关键词有以下作用：

• 声明一个或多个变量为易失性（或者说 "挥发性"）。
• 确保所有线程都能以一致的方式访问此类变量。
• 防止处理器对其执行重排序优化。

语法

volatile 关键词可以应用于实例变量和局部变量：

//实例变量
private volatile int counter;

//局部变量
public void incrementCounter() {
    volatile int count = counter;
    ...
}

重排序优化

处理器为了提升性能，经常会对指令进行重排序优化。然而，在多线程环境中，这可能导致线程访问共享变量时的不一致性。

考虑以下代码：

public class Counter {
    private int counter;

    public void incrementCounter() {
        counter++;
    }

    public int getCounter() {
        return counter;
    }
}

如果没有使用 volatile 关键词，处理器可能会对 incrementCounter() 方法和 getCounter() 方法中的指令进行重排序，导致读到的 counter 值不是最新的。

实战案例

以下是使用 volatile

Fungsi

🎜🎜meruap Kata kunci mempunyai fungsi berikut: 🎜

• Isytihar satu atau lebih pembolehubah sebagai tidak menentu (atau "meruap").
• Pastikan bahawa semua urutan boleh mengakses pembolehubah sedemikian dengan cara yang konsisten.
• Menghalang pemproses daripada melakukan pengoptimuman penyusunan semula padanya.

🎜🎜Syntax🎜🎜🎜meruap kata kunci boleh digunakan pada pembolehubah contoh dan pembolehubah tempatan: 🎜

public class VolatileCounterDemo {

    private volatile int counter;

    public void incrementCounter() {
        counter++;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileCounterDemo demo = new VolatileCounterDemo();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                demo.incrementCounter();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                demo.incrementCounter();
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("最终计数器值：" + demo.counter);
    }
}

🎜🎜Pengoptimuman penyusunan semula🎜🎜🎜Untuk meningkatkan prestasi, pemproses selalunya Arahan akan disusun semula dan dioptimumkan. Walau bagaimanapun, dalam persekitaran berbilang benang, ini boleh menyebabkan ketidakkonsistenan dalam akses benang kepada pembolehubah kongsi. 🎜🎜Pertimbangkan kod berikut: 🎜

最终计数器值：2000000

🎜Jika kata kunci volatile tidak digunakan, pemproses mungkin bertindak balas terhadap kaedah incrementCounter() dan getCounter() Arahan dalam kaedah disusun semula, menyebabkan nilai <code>counter dibaca bukan yang terkini. 🎜🎜🎜Kes praktikal🎜🎜🎜Berikut ialah contoh penggunaan kata kunci volatile untuk memastikan kaunter berfungsi dengan betul dalam persekitaran berbilang benang: 🎜rrreee🎜Output: 🎜rrreee

Atas ialah kandungan terperinci Peranan dan penggunaan kata kunci yang tidak menentu dalam pengaturcaraan selari Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!