Analisis mendalam tentang multithreading Java: memahami peralihan keadaan benang dan komunikasi antara benang

Analisis prinsip berbilang benang Java: peralihan keadaan benang dan komunikasi antara benang

Di Java, pengaturcaraan berbilang benang ialah kaedah biasa untuk mencapai pengkomputeran selari dan meningkatkan prestasi program. Pengaturcaraan berbilang benang boleh menggunakan sepenuhnya keupayaan berbilang teras komputer, membolehkan program melaksanakan berbilang tugas pada masa yang sama. Walau bagaimanapun, menulis program berbilang benang dengan betul dan memastikan ketepatan dan prestasinya adalah tugas yang agak rumit.

Artikel ini akan menganalisis prinsip Java multi-threading, memfokuskan pada peralihan keadaan thread dan komunikasi antara thread. Contoh kod konkrit disediakan untuk menggambarkan konsep ini.

1. Peralihan keadaan benang

Di Jawa, keadaan benang diwakili oleh jenis penghitungan Negeri dalam kelas Benang. Keadaan benang biasa adalah seperti berikut:

1.1 Baharu (Baharu): Apabila objek benang dicipta tetapi kaedah mula() belum dipanggil, benang berada dalam keadaan baharu.

1.2 Runnable: Selepas memanggil kaedah start(), thread berada dalam keadaan runnable. Benang dalam keadaan ini mungkin sedang menunggu pelaksanaan penjadualan CPU.

1.3 Disekat: Utas mungkin menggantung pelaksanaan kerana ia sedang menunggu sumber atau beberapa jenis situasi sekatan berlaku. Contohnya, apabila benang memanggil kaedah sleep() atau menunggu kunci pada objek, benang akan memasuki keadaan menyekat.

1.4 Menunggu: Benang mungkin memasuki keadaan menunggu kerana memanggil kaedah tunggu() dalam kelas Objek. Benang dalam keadaan menunggu perlu menunggu pemberitahuan daripada urutan lain sebelum ia boleh meneruskan pelaksanaan. Sebagai contoh, apabila benang menunggu syarat tertentu untuk dipenuhi.

1.5 Menunggu Bermasa: Sama seperti keadaan menunggu, tetapi dengan tamat masa. Utas boleh menunggu untuk masa yang ditentukan, dan jika tamat masa dicapai, utas akan terjaga secara automatik.

1.6 Ditamatkan: Selepas utas menyelesaikan tugasan atau ditamatkan secara tidak normal, ia memasuki keadaan ditamatkan.

Peralihan keadaan benang ditunjukkan dalam rajah di bawah:

           |
           V
New -> Runnable -> Blocked -> Runnable -> Terminated
           |    ^        |
           V    |        |
        Waiting <-       |
           |    |
           V    |
   Timed Waiting <---

Berikut ialah kod contoh ringkas yang menunjukkan proses penukaran keadaan benang:

public class ThreadStateExample {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(1000); // 线程进入Timed Waiting状态
                synchronized (ThreadStateExample.class) { // 线程进入Blocked状态
                    ThreadStateExample.class.wait(); // 线程进入Waiting状态
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("Thread state: " + thread.getState()); // NEW
        thread.start();
        System.out.println("Thread state: " + thread.getState()); // RUNNABLE
        Thread.sleep(200); // 让线程有足够的时间进入Timed Waiting状态
        System.out.println("Thread state: " + thread.getState()); // TIMED_WAITING
        Thread.sleep(1000); // 让线程有足够的时间进入Waiting状态
        System.out.println("Thread state: " + thread.getState()); // WAITING
        synchronized (ThreadStateExample.class) {
            ThreadStateExample.class.notify(); // 唤醒线程
        }
        Thread.sleep(200);
        System.out.println("Thread state: " + thread.getState()); // BLOCKED
        thread.join();
        System.out.println("Thread state: " + thread.getState()); // TERMINATED
    }
}

2. Komunikasi antara benang

Dalam pengaturcaraan berbilang benang , komunikasi antara benang adalah Satu teknologi yang penting. Komunikasi antara benang boleh merealisasikan kerjasama antara benang, membolehkan benang melaksanakan tugas dengan teratur.

Java menyediakan banyak kaedah komunikasi antara benang, termasuk memori yang dikongsi, mekanisme tunggu/beritahu, semafor, monitor, dsb. Antaranya, cara yang paling biasa adalah untuk mencapai komunikasi antara benang melalui objek yang dikongsi.

Objek yang dikongsi biasanya objek yang boleh diakses oleh berbilang rangkaian dan kerjasama antara rangkaian boleh dicapai dengan membaca dan menulis objek yang dikongsi.

Berikut ialah contoh kod ringkas yang menunjukkan cara komunikasi antara utas:

public class ThreadCommunicationExample {
    static class SharedObject {
        private int value;
        private boolean isValueReady;

        public synchronized int getValue() {
            while (!isValueReady) {
                try {
                    wait(); // 等待value准备好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return value;
        }

        public synchronized void setValue(int value) {
            this.value = value;
            isValueReady = true; // 设置value准备好的标记
            notify(); // 唤醒等待的线程
        }
    }

    public static void main(String[] args) {
        SharedObject sharedObject = new SharedObject();

        Thread readerThread = new Thread(() -> {
            int value = sharedObject.getValue();
            System.out.println("The value is: " + value);
        });

        Thread writerThread = new Thread(() -> {
            int value = 42;
            sharedObject.setValue(value);
        });

        readerThread.start();
        writerThread.start();
    }
}

Dalam kod di atas, komunikasi antara utas dicapai melalui objek yang dikongsisharedObject. Benang readerThread menunggu nilai bersedia sebelum membaca nilai, dan utas writerThread menetapkan nilai nilai Apabila nilai sudah sedia, utas readerThread dibangkitkan dan membaca nilai nilai.

Melalui analisis peralihan keadaan benang dan komunikasi antara benang di atas, kami boleh memahami dan menggunakan pengaturcaraan berbilang benang Java dengan lebih baik. Pada masa yang sama, kita perlu memberi perhatian kepada mekanisme penyegerakan dan penguncian dalam pengaturcaraan berbilang benang, serta mengelakkan kebuntuan dan isu keselamatan benang. Penggunaan munasabah teknologi berbilang benang boleh meningkatkan prestasi program dan kelajuan tindak balas dengan lebih baik.

Atas ialah kandungan terperinci Analisis mendalam tentang multithreading Java: memahami peralihan keadaan benang dan komunikasi antara benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!