Kajian mendalam tentang beberapa keadaan benang Java dan kesannya terhadap pelaksanaan program

Kajian mendalam tentang beberapa keadaan rangkaian Java dan kesannya terhadap pelaksanaan program

Di Java, utas ialah unit pelaksanaan ringan yang boleh berjalan secara bebas dalam program dan melaksanakan tugas tertentu. Status benang menerangkan peringkat pelaksanaan benang yang berbeza Memahami status utas adalah sangat penting untuk menulis program berbilang benang dan mengoptimumkan prestasi program. Artikel ini akan menyelidiki beberapa keadaan benang Java dan kesannya terhadap pelaksanaan program, dan memberikan contoh kod khusus.

Beberapa keadaan rangkaian Java termasuk: BARU (baharu), RUNNABLE (boleh dijalankan), DISEKAT (disekat), MENUNGGU (menunggu), MASA_MENUNGGU (menunggu bermasa) dan DITAMATKAN (ditamatkan).

1. Keadaan baharu (BARU): Apabila utas baharu dibuat dengan mencipta tika kelas Thread, utas berada dalam keadaan baharu. Dalam keadaan baharu, benang belum mula menjalankan sebarang kod. Berikut ialah contoh kod untuk mencipta utas baharu:

Thread thread = new Thread(() -> {
    System.out.println("Hello, World!");
});

2. Keadaan Boleh Lari (RUNNABLE): Apabila utas memanggil kaedah mula(), utas akan memasuki keadaan boleh jalan. Dalam keadaan ini, benang akan menunggu CPU memperuntukkan kepingan masa untuk melaksanakan kod dalam kaedah run(). Jika terdapat berbilang utas dalam keadaan boleh jalan, sistem pengendalian akan memperuntukkan kepingan masa kepada utas ini mengikut dasar penjadualan. Berikut ialah contoh kod:

Thread thread = new Thread(() -> {
    System.out.println("Hello, World!");
});
thread.start();

3. Keadaan disekat (DISEKAT): Apabila utas tidak dapat terus dilaksanakan atas sebab tertentu, utas akan memasuki keadaan disekat. Sebab biasa termasuk menunggu kunci, menunggu input dan output (I/O), dsb. Dalam keadaan menyekat, benang menangguhkan pelaksanaan sehingga syarat tertentu dipenuhi sebelum ia boleh meneruskan pelaksanaan. Berikut ialah contoh kod yang menggunakan kata kunci yang disegerakkan untuk mencapai penyegerakan benang:

public class MyRunnable implements Runnable {
    private Object lock = new Object();
    
    public void run() {
        synchronized(lock) {
            System.out.println("In synchronized block");
            // 一些代码
        }
    }
  
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
  
        thread1.start();
        thread2.start();
    }
}

Dalam kod di atas, dua utas cuba memasuki blok yang disegerakkan pada masa yang sama, kerana kunci dikongsi, benang kedua akan memasuki penyekatan nyatakan sehingga Benang pertama menyelesaikan pelaksanaan dan melepaskan kunci.

4. Keadaan Menunggu (MENUNGGU): Benang akan memasuki keadaan menunggu di bawah keadaan berikut: kaedah tunggu() dipanggil, kaedah join() dipanggil, atau kaedah park() LockSupport dipanggil. Dalam keadaan menunggu, utas tidak akan melaksanakan sebarang kod secara aktif sehingga utas lain membangunkannya atau masa menunggu tamat tempoh. Berikut ialah kod sampel menggunakan kaedah wait():

public class MyThread extends Thread {
    public void run() {
        synchronized(this) {
            System.out.println("Waiting for next thread...");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread resumed.");
        }
    }
  
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
  
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized(thread) {
            thread.notify();
        }
    }
}

Dalam kod di atas, selepas utas memasuki keadaan menunggu, utas utama membangunkan utas melalui kaedah notify().

5. Keadaan menunggu masa (TIMED_WAITING): Utas akan memasuki keadaan menunggu bermasa di bawah keadaan berikut: kaedah sleep() dipanggil, kaedah join() dengan parameter tamat masa dipanggil dan wait() dengan parameter tamat masa dipanggil kaedah, memanggil kaedah parkNanos() atau kaedah parkUntil() LockSupport. Dalam keadaan menunggu yang dijadualkan, urutan tidak akan melaksanakan sebarang kod secara aktif dan akan dibangkitkan selepas masa menunggu dicapai. Berikut ialah kod sampel menggunakan kaedah sleep():

public class MyThread extends Thread {
    public void run() {
        try {
            System.out.println("Thread sleeping...");
            Thread.sleep(2000);
            System.out.println("Thread woke up.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
  
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

Dalam kod di atas, utas memasuki keadaan menunggu yang dijadualkan dengan memanggil kaedah sleep() dan menunggu selama 2 saat sebelum dikejutkan.

6. Keadaan TERMINAT: Selepas utas selesai melaksanakan kod dalam kaedah run(), thread akan memasuki keadaan ditamatkan. Dalam keadaan ditamatkan, benang tidak akan berjalan lagi.

Ringkasnya, status utas mempunyai kesan penting terhadap pelaksanaan program. Memahami pelbagai negeri dan maksudnya adalah penting untuk menulis program berbilang benang yang cekap.

Bahan rujukan:

• Dokumentasi rasmi Oracle - Keadaan benang Java: https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.State.html
• Pengenalan berbilang benang Java tutorial ：https://www.journaldev.com/1162/java-thread-tutorial

Atas ialah kandungan terperinci Kajian mendalam tentang beberapa keadaan benang Java dan kesannya terhadap pelaksanaan program. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!