Apakah amalan terbaik dalam pengaturcaraan serentak di Java?

Ikuti amalan terbaik pengaturcaraan serentak Java untuk mengelakkan kebuntuan, keadaan perlumbaan dan rasuah data. Amalan ini termasuk: Memahami keselamatan benang Menggunakan penyegerakan Mengelakkan kebuntuan Menggunakan kumpulan benang Menggunakan koleksi serentak

Amalan Terbaik dalam Pengaturcaraan Serentak di Java

Pengaturcaraan serentak melibatkan pengendalian berbilang tugasan yang dilaksanakan secara serentak. Di Jawa, konkurensi dicapai melalui multithreading. Jika amalan terbaik tidak diikuti, pengaturcaraan serentak boleh membawa kepada masalah seperti kebuntuan, keadaan perlumbaan dan rasuah data.

1. Fahami keselamatan benang

Keselamatan benang bermaksud kelas atau kaedah boleh berfungsi dengan betul apabila diakses oleh berbilang benang pada masa yang sama. Kelas selamat benang di Java termasuk mekanisme penyegerakan seperti kunci dan operasi atom untuk mengelakkan rasuah data.

2. Gunakan penyegerakan

Apabila berbilang rangkaian mengakses data kongsi, penyegerakan perlu digunakan untuk mengelakkan keadaan perlumbaan. Di Java, penyegerakan boleh dicapai dengan menggunakan kata kunci yang disegerakkan, objek kunci atau pembolehubah atom.

3. Elakkan kebuntuan

Kebuntuan berlaku apabila dua atau lebih utas menunggu antara satu sama lain untuk melepaskan sumber. Untuk mengelakkan kebuntuan, يجب ikut peraturan ini:

• Elakkan menunggu bulat: Jangan sekali-kali ada satu utas menunggu untuk utas lain yang juga sedang menunggu untuk utas pertama.
• Peroleh kunci dalam susunan yang sama: Apabila berbilang kunci perlu diperoleh, sentiasa dapatkan kunci itu dalam susunan yang sama.

4. Gunakan kumpulan benang

Kolam benang menguruskan set benang boleh guna semula yang boleh dibuat atau dimusnahkan mengikut keperluan. Ini membantu meningkatkan prestasi dan kebolehskalaan.

5. Menggunakan koleksi serentak

Java menyediakan rangka kerja koleksi serentak yang mengandungi kelas koleksi selamat benang yang mudah digunakan. Menggunakan kelas ini mengelakkan isu keselamatan benang yang boleh timbul apabila menggunakan koleksi biasa.

Kes praktikal

Andaikan kita mempunyai sumber kongsi Counter, yang mewakili integer. Kami mahu menggunakan dua benang untuk menambah pembilang secara serentak. Jika penyegerakan tidak digunakan, keadaan perlumbaan boleh berlaku kerana dua utas boleh mengakses dan mengemas kini kaunter pada masa yang sama, mengakibatkan keputusan yang tidak tepat. Counter，它表示一个整数。我们想使用两个线程同时增加计数器。如果不使用同步，就会发生竞态条件，因为两个线程可能会同时访问并更新计数器，导致不准确的结果。

使用以下代码可以安全地更新计数器：

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

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

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

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

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

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

        System.out.println(counter.getCount()); // 输出：200000
    }
}

在上面的示例中，我们使用 AtomicInteger

Kaunter boleh dikemas kini dengan selamat menggunakan kod berikut: 🎜rrreee🎜Dalam contoh di atas, kami menggunakan AtomicInteger untuk melaksanakan pembilang selamat benang, yang menyediakan operasi atom untuk mengemas kini nilai kiraan. 🎜

Atas ialah kandungan terperinci Apakah amalan terbaik dalam pengaturcaraan serentak di Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!