Penjelasan terperinci tentang senario penggunaan dan fungsi kata kunci yang tidak menentu dalam Java

Penjelasan terperinci tentang peranan dan senario aplikasi kata kunci yang tidak menentu dalam Java

1 Peranan kata kunci yang tidak menentu
Di Jawa, kata kunci yang tidak menentu digunakan untuk mengenal pasti pembolehubah yang boleh dilihat antara berbilang benang, iaitu. , untuk memastikan keterlihatan. Khususnya, apabila pembolehubah diisytiharkan tidak menentu, sebarang pengubahsuaian pada pembolehubah itu akan diketahui dengan serta-merta oleh rangkaian lain.

2. Senario aplikasi kata kunci yang tidak menentu

1. Bendera status
   Kata kunci yang tidak menentu sesuai untuk beberapa senario bendera status, seperti satu urutan yang bertanggungjawab untuk memulakan dan menghentikan pelaksanaan urutan lain. Berikut ialah contoh:

public class FlagThread {
    private volatile boolean running = true;
    
    public void setRunning(boolean running) {
        this.running = running;
    }
    
    public void run() {
        while (running) {
            // 执行任务
        }
        // 停止执行
    }
    
    public static void main(String[] args) {
        FlagThread thread = new FlagThread();
        thread.start();
        
        // 模拟运行一段时间后停止执行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        thread.setRunning(false);
    }
}

Dalam kod di atas, pembolehubah berjalan dalam kelas FlagThread diisytiharkan tidak menentu. Apabila utas utama ditetapkan berjalan kepada false, utas FlagThread segera mengesannya dan menghentikan pelaksanaan.

2. Penguncian yang disemak dua kali dalam mod tunggal
   Dalam sesetengah kes, kita perlu memastikan bahawa apabila berbilang benang mengakses pembolehubah pada masa yang sama, pembolehubah hanya dimulakan sekali. Berikut ialah contoh corak tunggal yang dilaksanakan menggunakan penguncian yang disemak dua kali:

public class Singleton {
    private volatile static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Dalam kod di atas, pembolehubah contoh diisytiharkan tidak menentu. Ini kerana dalam persekitaran berbilang benang, jika kata kunci yang tidak menentu tidak digunakan, disebabkan masalah penyusunan semula arahan, apabila berbilang benang mengakses kaedah getInstance pada masa yang sama, contoh yang dikembalikan bukanlah objek yang dimulakan sepenuhnya.

3. Perkongsian data antara dua utas
   Dalam pengaturcaraan berbilang benang, kata kunci yang tidak menentu juga boleh digunakan untuk perkongsian data antara dua utas. Berikut ialah contoh:

public class SharedData {
    private volatile int data;
    
    public int getData() {
        return data;
    }
    
    public void setData(int data) {
        this.data = data;
    }
}

public class Producer implements Runnable {
    private SharedData sharedData;
    
    public Producer(SharedData sharedData) {
        this.sharedData = sharedData;
    }
    
    @Override
    public void run() {
        int value = 0;
        while (true) {
            sharedData.setData(value);
            value++;
        }
    }
}

public class Consumer implements Runnable {
    private SharedData sharedData;
    
    public Consumer(SharedData sharedData) {
        this.sharedData = sharedData;
    }
    
    @Override
    public void run() {
        while (true) {
            int value = sharedData.getData();
            System.out.println(value);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SharedData sharedData = new SharedData();
        Thread producerThread = new Thread(new Producer(sharedData));
        Thread consumerThread = new Thread(new Consumer(sharedData));
        
        producerThread.start();
        consumerThread.start();
    }
}

Dalam kod di atas, utas Pengeluar secara berterusan menulis data kepada pembolehubah data objek sharedData, manakala utas Pengguna secara berterusan membaca data daripada pembolehubah data. Memandangkan pembolehubah data diisytiharkan tidak menentu, operasi tulis thread Producer kepada data kelihatan kepada thread Consumer.

3. Ringkasan
Kata kunci yang tidak menentu memainkan peranan penting dalam pengaturcaraan berbilang benang Java Ia digunakan untuk memastikan keterlihatan pembolehubah. Dalam sesetengah senario, kita perlu memastikan bahawa pengubahsuaian kepada pembolehubah antara berbilang utas dapat dilihat oleh utas lain Dalam kes ini, kata kunci yang tidak menentu boleh digunakan. Walau bagaimanapun, perlu diingatkan bahawa kata kunci yang tidak menentu hanya boleh menjamin keterlihatan, tetapi bukan keatoman pembolehubah Jika anda perlu memastikan keatoman, anda boleh mempertimbangkan untuk menggunakan kata kunci yang disegerakkan atau kelas Atom.

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