Bagaimana untuk menggunakan benang dalam Java

Cara menggunakan Thread dalam Java, contoh kod khusus

1. Pengenalan
   Di Java, pengaturcaraan berbilang benang ialah cara yang berkesan untuk meningkatkan kecekapan dan keselarasan program. Kelas Thread ialah kelas teras dalam Java yang digunakan untuk mencipta dan mengurus benang. Artikel ini akan memperkenalkan penggunaan kelas Thread secara terperinci dan menyediakan beberapa contoh kod khusus.
2. Cipta Thread
   Objek thread boleh dibuat dalam dua cara: mewarisi kelas Thread dan melaksanakan antara muka Runnable. Mewarisi kelas Thread adalah cara yang mudah, tetapi memandangkan Java hanya menyokong warisan tunggal, kaedah ini akan mengehadkan kebolehskalaan kod. Melaksanakan antara muka Runnable boleh mengelakkan masalah ini, kerana Java menyokong pelaksanaan berbilang antara muka.

Berikut ialah contoh kod menggunakan dua kaedah untuk mencipta utas:

// 继承Thread类
class MyThread extends Thread {
    public void run(){
        // 线程执行的代码
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable {
    public void run(){
        // 线程执行的代码
    }
}

// 创建线程并启动
public static void main(String[] args){
    // 创建继承Thread类的线程
    MyThread thread1 = new MyThread();
    thread1.start();

    // 创建实现Runnable接口的线程
    MyRunnable runnable = new MyRunnable();
    Thread thread2 = new Thread(runnable);
    thread2.start();
}

Dalam kod di atas, utas yang dicipta dengan mewarisi kelas Thread secara terus memanggil kaedah mula untuk memulakan utas, manakala utas dicipta dengan melaksanakan antara muka Runnable Benang perlu mencipta objek Thread terlebih dahulu, lulus objek yang melaksanakan antara muka Runnable sebagai parameter kepada pembina Thread, dan kemudian panggil kaedah permulaan objek Thread untuk memulakan thread.

3. Kitaran hayat benang
   Sebuah benang akan melalui berbilang keadaan selepas ia dibuat, dan keadaan ini dipanggil kitaran hayat benang. Keadaan urutan biasa ialah: Baharu, Boleh Dijalankan, Berjalan, Disekat dan Ditamatkan.

Berikut ialah contoh mudah yang menunjukkan kitaran hayat utas:

class MyThread extends Thread {
    public void run(){
        System.out.println("线程执行中");

        try {
            Thread.sleep(1000); // 线程等待1秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("线程执行结束");
    }
}

public static void main(String[] args){
    MyThread thread = new MyThread();
    System.out.println("线程状态：" + thread.getState()); // 输出线程状态为New
    thread.start();
    System.out.println("线程状态：" + thread.getState()); // 输出线程状态为Runnable
    // 等待线程执行结束
    try {
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("线程状态：" + thread.getState()); // 输出线程状态为Terminated
}

Dalam kod di atas, selepas utas baharu dicipta dan dimulakan, status utas pertama kali dikeluarkan menjadi Baharu, dan kemudian status adalah Runnable. Selepas memanggil kaedah thread.join() dan menunggu sehingga thread selesai dilaksanakan, status output akhir ditamatkan.

4. Penyegerakan benang dan pengecualian bersama
   Dalam pengaturcaraan berbilang benang, penyegerakan benang dan pengecualian bersama adalah konsep yang sangat penting. Apabila berbilang rangkaian mengakses sumber yang dikongsi pada masa yang sama, untuk mengelakkan keadaan perlumbaan dan ketidakkonsistenan data, langkah penyegerakan yang sesuai perlu diambil.

Java menyediakan mekanisme seperti kata kunci yang disegerakkan dan antara muka Kunci untuk mencapai penyegerakan benang dan pengecualian bersama. Berikut ialah contoh penggunaan kata kunci disegerakkan untuk penyegerakan benang:

class Counter {
    private int count = 0;

    // 线程安全的方法
    public synchronized void increment(){
        count++;
    }

    public int getCount(){
        return count;
    }
}

public static void main(String[] args){
    Counter counter = new Counter();

    Runnable runnable = () -> {
        for(int i=0; i<10000; i++){
            counter.increment();
        }
    };

    Thread thread1 = new Thread(runnable);
    Thread thread2 = new Thread(runnable);

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

    try {
        thread1.join();
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("计数器的值：" + counter.getCount()); // 输出：20000
}

Dalam contoh kod di atas, kelas Kaunter selamat benang ditakrifkan, di mana kaedah kenaikan menggunakan kata kunci disegerakkan untuk menyegerakkan data kongsi. Dua utas dipanggil objek Counter pada masa yang sama Setiap utas melakukan 10,000 operasi kenaikan pada kiraan, dan akhirnya mengeluarkan hasil yang betul sebanyak 20,000.

5. Gangguan utas
   Java menyediakan mekanisme untuk mengganggu utas yang sedang berjalan Anda boleh memanggil kaedah sampukan kelas Thread untuk menghantar isyarat gangguan. Benang yang terganggu boleh menentukan sama ada isyarat gangguan telah diterima dengan memanggil kaedah isInterrupted, dan kemudian mengambil tindakan yang sesuai seperti yang diperlukan.

Berikut ialah contoh kod yang menunjukkan cara untuk mengganggu urutan:

class MyThread extends Thread {
    public void run(){
        while(!isInterrupted()){
            System.out.println("线程运行中");
            try {
                Thread.sleep(1000); // 线程等待1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }
        }
        System.out.println("线程中断");
    }
}

public static void main(String[] args){
    MyThread thread = new MyThread();
    thread.start();

    try {
        Thread.sleep(5000); // 主线程等待5秒
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    thread.interrupt(); // 中断线程
}

Dalam kod di atas, selepas urutan baharu dicipta dan dimulakan, utas utama menunggu selama 5 saat dan kemudian mengganggu utas anak.

Ringkasan:
Artikel ini memperkenalkan cara menggunakan kelas Thread dalam Java dan menyediakan beberapa contoh kod khusus. Anda boleh mencipta utas dengan mewarisi kelas Thread atau melaksanakan antara muka Runnable, dan mulakan utas dengan memanggil kaedah mula. Memahami kitaran hayat benang dan konsep penyegerakan benang dan pengecualian bersama adalah sangat penting untuk menulis program berbilang benang yang teguh. Pada masa yang sama, memahami cara mengganggu benang juga merupakan titik pengetahuan penting dalam pengaturcaraan berbilang benang. Menguasai kandungan ini boleh membantu pembangun menggunakan pengaturcaraan berbilang benang untuk meningkatkan kecekapan dan keselarasan program.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan benang dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!