Menyelam mendalam ke dalam pengaturcaraan serentak Java: dari tunggu dan maklumkan kepada java.util.concurrent

Daripada tunggu dan maklumkan kepada java.util.concurrent: Teroka kaedah lanjutan pengaturcaraan serentak Java

Dalam pengaturcaraan Java, melaksanakan concurrency adalah tugas biasa tetapi juga mencabar. Untuk menyelesaikan masalah konkurensi dengan berkesan, Java menyediakan beberapa alat dan kelas asas, seperti kata kunci yang disegerakkan, kaedah tunggu dan maklumkan, dan kelas Thread. Walau bagaimanapun, apabila aplikasi berkembang dalam kerumitan, alat asas ini sering gagal. Untuk mengendalikan concurrency dengan lebih baik, Java juga memperkenalkan pakej java.util.concurrent, yang menyediakan beberapa kaedah dan alatan pengaturcaraan serentak yang lebih maju. Artikel ini akan meneroka beberapa kaedah lanjutan daripada menunggu dan memberitahu kepada java.util.concurrent, sambil memberikan contoh kod khusus.

tunggu dan maklumkan ialah kaedah dalam kelas Objek dan digunakan untuk melaksanakan komunikasi antara utas. Kaedah tunggu meletakkan utas dalam keadaan menunggu sehingga utas lain memanggil kaedah pemberitahuan untuk membangunkannya. Mekanisme ini digunakan secara meluas untuk mencapai penyegerakan antara benang. Berikut ialah contoh mudah:

public class WaitNotifyExample {
    public static void main(String[] args) {
        final Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1 is waiting");
                    lock.wait();
                    System.out.println("Thread 1 is resumed");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 is notifying");
                lock.notify();
            }
        });

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

Kod di atas mencipta dua utas, di mana utas1 memanggil kaedah tunggu untuk memasuki keadaan menunggu, dan utas2 memanggil kaedah pemberitahuan untuk membangunkan utas1. Dengan cara ini, thread1 akan meneruskan pelaksanaan.

Walau bagaimanapun, mekanisme menunggu dan pemberitahuan asas ini selalunya tidak fleksibel dan cekap dalam aplikasi praktikal. Ia tidak dapat menyelesaikan isu konkurensi yang kompleks seperti pengurusan kumpulan benang, kunci masuk semula, kunci baca-tulis, dsb. Untuk menangani masalah ini dengan lebih baik, Java menyediakan pakej java.util.concurrent.

Pakej ini menyediakan beberapa kaedah dan alatan pengaturcaraan serentak yang lebih maju. Berikut ialah beberapa kelas dan antara muka yang biasa digunakan:

1. Antara muka pelaksana: mentakrifkan alatan peringkat tinggi untuk mengurus pelaksanaan utas. Benang boleh dibuat dan diurus menggunakan kelas pelaksanaan yang disediakan oleh kumpulan benang.

Executor executor = Executors.newFixedThreadPool(5);
executor.execute(() -> {
    // 执行任务
});

2. Antara muka kunci: Menyediakan mekanisme kunci yang lebih fleksibel dan masuk semula daripada disegerakkan. ReentrantLock ialah pelaksanaan antara muka Lock.

Lock lock = new ReentrantLock();
lock.lock();
try {
    // 执行线程安全的操作
} finally {
    lock.unlock();
}

3. Antara muka keadaan: Digunakan bersama antara muka Kunci untuk mencapai komunikasi antara benang yang lebih tepat. Fungsi menunggu dan pemberitahuan boleh dilaksanakan melalui menunggu, isyarat dan isyaratSemua kaedah.

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

lock.lock();
try {
    while (!conditionIsMet()) {
        condition.await();
    }
    // 执行逻辑
} finally {
    lock.unlock();
}

4. Kelas CountDownLatch: digunakan untuk mengawal penantian pelaksanaan benang. Anda boleh menentukan pembilang Apabila pembilang mencapai 0, utas menunggu akan meneruskan pelaksanaan.

CountDownLatch latch = new CountDownLatch(3);

Thread thread1 = new Thread(() -> {
    // 执行任务
    latch.countDown();
});

Thread thread2 = new Thread(() -> {
    // 执行任务
    latch.countDown();
});

Thread thread3 = new Thread(() -> {
    // 执行任务
    latch.countDown();
});

latch.await();
// 等待三个线程执行完毕后继续执行

5. Kelas semaphore: digunakan untuk mengawal bilangan utas yang mengakses sumber pada masa yang sama. Anda boleh mengehadkan bilangan utas yang dilaksanakan secara serentak.

Semaphore semaphore = new Semaphore(3);

Thread thread1 = new Thread(() -> {
    try {
        semaphore.acquire();
        // 执行任务
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        semaphore.release();
    }
});

Thread thread2 = new Thread(() -> {
    try {
        semaphore.acquire();
        // 执行任务
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        semaphore.release();
    }
});

// 最多允许3个线程同时执行

Dengan menggunakan kaedah dan alatan termaju ini, kami boleh menangani isu konkurensi dengan lebih baik dan meningkatkan prestasi serta kebolehpercayaan aplikasi kami. Walau bagaimanapun, adalah penting untuk ambil perhatian bahawa pertimbangan berhati-hati terhadap keselamatan benang dan kawalan konkurensi diperlukan apabila menggunakan ciri ini.

Untuk meringkaskan, Java menyediakan kaedah lanjutan daripada kaedah menunggu asas dan memberitahu kepada pakej java.util.concurrent yang lebih maju untuk mengendalikan pengaturcaraan serentak. Kita boleh memilih kaedah dan alat yang sesuai berdasarkan keperluan sebenar dan kerumitan masalah. Dengan memanfaatkan kaedah pengaturcaraan serentak dengan betul, kami boleh mengurus pelaksanaan benang dengan lebih baik, mengelakkan keadaan perlumbaan dan kebuntuan serta meningkatkan prestasi dan kualiti aplikasi.

Saya harap kod sampel dan kaedah yang disediakan dalam artikel ini akan membantu anda dalam pembelajaran dan amalan pengaturcaraan serentak di Jawa.

Atas ialah kandungan terperinci Menyelam mendalam ke dalam pengaturcaraan serentak Java: dari tunggu dan maklumkan kepada java.util.concurrent. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!