Penerangan terperinci tentang lima keadaan benang Java dan ciri serta prestasinya dalam persekitaran berbilang benang

. meningkatkan keselarasan dan responsif Program. Di Java, benang mempunyai lima keadaan berbeza, iaitu keadaan baharu (Baru), keadaan boleh dijalankan (boleh dijalankan), keadaan disekat (disekat), keadaan menunggu (menunggu) dan keadaan penamatan (ditamatkan). Artikel ini akan memperkenalkan ciri lima keadaan ini secara terperinci, dan menunjukkan prestasi dalam persekitaran berbilang benang melalui contoh kod tertentu.

1. Keadaan baharu (Baru)

Keadaan di mana benang telah dibuat tetapi belum mula berjalan dipanggil keadaan baharu. Dalam keadaan yang baru dibuat, kaedah mula () benang belum lagi dipanggil, jadi pelaksanaan sebenarnya belum dimulakan. Pada masa ini, objek benang telah dibuat, tetapi sistem pengendalian tidak memperuntukkan sumber pelaksanaan kepadanya.

2. Keadaan boleh dijalankan (Boleh Dijalankan)

Selepas benang dipanggil dengan kaedah mula(), ia memasuki keadaan boleh dijalankan. Benang dalam keadaan ini menggunakan CPU untuk melaksanakan tugasnya, tetapi mungkin digantung disebabkan oleh utas keutamaan tinggi yang lain, kehabisan potongan masa atau menunggu input/output. Dalam keadaan boleh jalan, benang mempunyai ciri-ciri berikut:

Benang dalam keadaan ini ialah unit asas penjadualan sistem pengendalian.

Berbilang utas dilaksanakan secara serentak, dan kepingan masa CPU diperuntukkan kepada setiap utas supaya ia dilaksanakan secara bergilir-gilir.

Penjadualan benang tidak boleh dikawal kerana ia ditentukan oleh sistem pengendalian.

1. Berikut ialah contoh kod ringkas yang menunjukkan keadaan boleh jalan bagi dua utas:

2. class MyRunnable implements Runnable{
       public void run(){
           for(int i=0; i<10; i++){
               System.out.println(Thread.currentThread().getName() + ": " + i);
           }
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           Thread t1 = new Thread(new MyRunnable());
           Thread t2 = new Thread(new MyRunnable());
           
           t1.start();
           t2.start();
       }
   }

Dalam contoh di atas, kami mencipta dua utas t1 dan t2 dan memulakannya serentak. Oleh kerana kedua-dua utas berjalan serentak, outputnya akan silih berganti.
3. Keadaan disekat (Disekat)

Benang memasuki keadaan disekat kerana ia tidak dapat memperoleh sumber tertentu atau sedang menunggu syarat tertentu untuk dipenuhi. Benang dalam keadaan disekat tidak akan menggunakan masa CPU sehingga ia memperoleh sumber atau memasuki keadaan boleh jalan apabila syarat dipenuhi.

Berikut ialah contoh kod ringkas yang menunjukkan keadaan menyekat benang:

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1 is waiting");
                    lock.wait();
                    System.out.println("Thread 1 is running again");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
                
                synchronized (lock) {
                    System.out.println("Thread 2 is waking up Thread 1");
                    lock.notify();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        t1.start();
        t2.start();
    }
}

Dalam contoh di atas, kami mencipta dua utas t1 dan t2, t1 memasuki menunggu dengan memanggil kaedah wait() semasa keadaan pelaksanaan sehingga t2 membangunkannya melalui kaedah notify(). Sebab t1 disekat di sini ialah ia tidak boleh meneruskan pelaksanaan sehingga t2 mengeluarkan pemberitahuan. Apabila t2 menghantar pemberitahuan, t1 menyahsekat dan memasuki semula keadaan boleh jalan.

4. Keadaan menunggu (Menunggu)

Sesuatu benang memasuki keadaan menunggu kerana ia perlu menunggu urutan lain untuk mengambil beberapa tindakan tertentu. Urutan dalam keadaan menunggu menunggu sehingga ia dimaklumkan atau terganggu.

Berikut ialah contoh kod ringkas yang menunjukkan keadaan menunggu sesuatu benang:

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 is waiting");
                try {
                    lock.wait(); // 进入等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                System.out.println("Thread 1 is running again");
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
                
                synchronized (lock) {
                    System.out.println("Thread 2 is waking up Thread 1");
                    lock.notify(); // 唤醒等待的线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        t1.start();
        t2.start();
    }
}

Dalam contoh di atas, kami meletakkan benang t1 ke dalam keadaan menunggu melalui kaedah lock.wait() sehingga benang t2 melepasi kunci.notify ( ) kaedah untuk memberitahunya.

5. Keadaan ditamatkan (Ditamatkan)

Apabila benang menyelesaikan tugasnya atau keluar kerana pengecualian, ia memasuki keadaan ditamatkan. Urutan dalam keadaan ditamatkan tidak lagi dilaksanakan dan tidak boleh dimulakan semula.

Berikut ialah contoh kod ringkas yang menunjukkan status penamatan urutan:

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for(int i=0; i<10; i++){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        });
        
        t1.start();
        
        try {
            t1.join(); // 确保线程执行完
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Thread 1 is terminated");
    }
}

Dalam contoh di atas, kami mencipta utas t1 dan memulakannya. Kemudian gunakan kaedah t1.join() untuk memastikan bahawa benang terus melaksanakan kod berikutnya selepas ia selesai melaksanakan.

Ringkasnya, artikel ini memperkenalkan lima keadaan benang Java dan ciri serta prestasinya dalam persekitaran berbilang benang. Untuk pengaturcaraan berbilang benang, adalah penting untuk memahami peralihan dan ciri keadaan benang Menggunakan keadaan benang yang sesuai boleh menjadikan program lebih cekap dan boleh dipercayai. Saya berharap melalui pengenalan artikel ini, pembaca dapat lebih memahami mekanisme kerja benang Java dan menggunakan pengaturcaraan berbilang benang dengan betul dalam projek sebenar.

Atas ialah kandungan terperinci Penerangan terperinci tentang lima keadaan benang Java dan ciri serta prestasinya dalam persekitaran berbilang benang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!