Analisis kaedah komunikasi berbilang benang Java

Di Java, kaedah komunikasi berbilang benang termasuk pembolehubah kongsi, tunggu/beritahu, semaphore dan paip. Pembolehubah yang dikongsi memudahkan pertukaran data tetapi terdedah kepada isu konkurensi tunggu/beritahu menggunakan mekanisme penyegerakan untuk menunggu dan bangun antara utas mengehadkan bilangan utas yang mengakses sumber pada masa yang sama;

Analisis komunikasi berbilang benang Java

Pengenalan

Multi-threading ialah konsep penting dalam pengaturcaraan serentak, yang membolehkan berbilang tugasan dilaksanakan secara serentak Untuk melaksanakan pertukaran data dalam persekitaran berbilang benang, kita perlu memahami pelbagai kaedah komunikasi. Artikel ini akan melihat secara mendalam kaedah komunikasi berbilang benang biasa di Jawa, termasuk pembolehubah kongsi, tunggu/beritahu, semaphore dan paip.

Pembolehubah dikongsi

Pembolehubah yang dikongsi ialah pembolehubah global yang boleh diakses oleh berbilang urutan. Apabila satu utas mengubah suai pembolehubah yang dikongsi, utas lain boleh melihat perubahan itu. Walau bagaimanapun, pembolehubah yang dikongsi terdedah kepada masalah konkurensi, seperti keadaan kaum dan tingkah laku yang tidak dapat diramalkan.

Kes praktikal:

public class SharedVariableExample {
    private static int sharedCounter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                sharedCounter++;
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                sharedCounter--;
            }
        });

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

        thread1.join();
        thread2.join();

        System.out.println("最终共享计数器：" + sharedCounter);
    }
}

tunggu/beritahu

tunggu/beritahu ialah mekanisme penyegerakan terbina dalam Java. Kaedah wait() akan meletakkan utas semasa ke dalam keadaan menunggu sehingga utas lain memanggil kaedah notify() atau notifyAll() untuk membangunkannya.

Kes praktikal:

public class WaitNotifyExample {
    private static Object lock = new Object();

    private static boolean dataAvailable = false;

    public static void main(String[] args) throws InterruptedException {
        Thread producer = new Thread(() -> {
            synchronized (lock) {
                while (!dataAvailable) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                System.out.println("处理数据...");
            }
        });

        Thread consumer = new Thread(() -> {
            synchronized (lock) {
                dataAvailable = true;
                lock.notify();
            }
        });

        producer.start();
        consumer.start();

        producer.join();
        consumer.join();
    }
}

Semaphore

Semaphore ialah mekanisme penyegerakan yang membenarkan bilangan utas tertentu untuk mengakses sumber pada masa yang sama. Apabila benang memperoleh semaphore, pembilang semaphore dikurangkan apabila ia melepaskan semaphore, pembilang itu dinaikkan.

Kes praktikal:

public class SemaphoreExample {
    private static Semaphore semaphore = new Semaphore(2);

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("线程 1 进入临界区");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("线程 2 进入临界区");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        });

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

        thread1.join();
        thread2.join();
    }
}

Pipeline

Pipeline ialah struktur data khas yang digunakan untuk komunikasi antara benang. Ia seperti penampan, satu benang boleh menulis data dan satu lagi benang boleh membaca data.

Kes praktikal:

public class PipeExample {
    private static PipedOutputStream pos = new PipedOutputStream();
    private static PipedInputStream pis = new PipedInputStream(pos);

    public static void main(String[] args) throws IOException {
        Thread writer = new Thread(() -> {
            try {
                pos.write("你好，世界！".getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                pos.close();
            }
        });

        Thread reader = new Thread(() -> {
            try {
                byte[] data = new byte[1024];
                int length = pis.read(data);
                System.out.println(new String(data, 0, length));
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                pis.close();
            }
        });

        writer.start();
        reader.start();

        writer.join();
        reader.join();
    }
}

Atas ialah kandungan terperinci Analisis kaedah komunikasi berbilang benang Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!