Cara menggunakan fungsi Thread dalam Java untuk operasi thread

Fungsi Thread dalam Java ialah kelas yang disediakan oleh Java untuk mencipta dan mengawal benang. Benang boleh melaksanakan operasi serentak dalam program dan meningkatkan kecekapan menjalankan program. Fungsi Benang menyediakan banyak kaedah untuk memudahkan operasi benang. Artikel ini akan memperkenalkan cara menggunakan fungsi Thread dalam Java untuk operasi thread.

1. Mencipta utas

Terdapat dua cara untuk mencipta utas dalam Java: mewarisi kelas Thread dan melaksanakan antara muka Runnable. Mewarisi kelas Thread ialah pendekatan yang lebih mudah, tetapi dihadkan oleh model warisan tunggal Java. Melaksanakan antara muka Runnable ialah pendekatan yang lebih fleksibel yang mengelakkan masalah ini.

Kod yang mewarisi kelas Thread adalah seperti berikut:

class MyThread extends Thread {
    public void run() {
        // 线程运行的代码
    }
}

// 创建线程
MyThread thread = new MyThread();

// 启动线程
thread.start();

Kod yang melaksanakan antara muka Runnable adalah seperti berikut:

class MyRunnable implements Runnable {
    public void run() {
        // 线程运行的代码
    }
}

// 创建线程
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);

// 启动线程
thread.start();

2. Mengawal benang

Fungsi Thread dalam Java menyediakan beberapa kaedah untuk mengawal benang dengan mudah. Berikut adalah beberapa kaedah yang biasa digunakan.

1) kaedah tidur: biarkan benang tidur untuk tempoh masa, unit adalah milisaat.

try {
    Thread.sleep(1000); // 线程睡眠1秒钟
} catch (InterruptedException e) {
    e.printStackTrace();
}

2) Kaedah hasil: Serahkan hak pelaksanaan CPU bagi utas semasa dan beri peluang kepada utas lain untuk dijalankan.

Thread.yield();

3) kaedah sertai: tunggu thread lain selesai melaksanakan sebelum melaksanakan.

try {
    thread.join(); // 等待thread线程执行完毕后再执行
} catch (InterruptedException e) {
    e.printStackTrace();
}

4) kaedah sampuk: sampuk benang.

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

3. Penyegerakan benang

Penyegerakan benang bermaksud bahawa dalam persekitaran berbilang benang, memandangkan pelaksanaan berbilang benang tidak pasti, dua atau lebih benang boleh mengubah suai sumber dikongsi yang sama pada masa yang sama, mengakibatkan data Tidak konsisten. Java menyediakan kata kunci yang disegerakkan dan mekanisme kunci untuk menyelesaikan masalah ini.

class MyThread implements Runnable {
    private Integer count = 0;

    public synchronized void run() {
        for (int i = 0; i < 10; i++) {
            count++; // 对共享资源进行操作
            System.out.println(Thread.currentThread().getName() + " count: " + count);
            Thread.yield();
        }
    }
}

// 创建两个线程
MyThread runnable = new MyThread();
Thread t1 = new Thread(runnable, "Thread1");
Thread t2 = new Thread(runnable, "Thread2");

// 启动两个线程
t1.start();
t2.start();

Dalam kod di atas, kami menggunakan kata kunci yang disegerakkan untuk memastikan akses berbilang rangkaian kepada pembolehubah kiraan adalah saling eksklusif.

4. Kolaborasi utas

Kolaborasi utas merujuk kepada kerjasama antara berbilang utas, membolehkan mereka melaksanakan dalam susunan tertentu. Fungsi Thread dalam Java menyediakan kaedah tunggu dan maklumkan untuk mencapai kerjasama utas.

class MyThread implements Runnable {
    private boolean running = true;

    public synchronized void run() {
        while (running) {
            try {
                System.out.println(Thread.currentThread().getName() + " is running");
                wait(); // 等待其他线程唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " is stopped");
    }

    public synchronized void stop() {
        running = false;
        notify(); // 唤醒其他线程
    }
}

// 创建线程
MyThread runnable = new MyThread();
Thread thread = new Thread(runnable);

// 开始线程
thread.start();

// 停止线程
runnable.stop();

Dalam kod di atas, kami menggunakan kaedah tunggu untuk membiarkan utas menunggu sehingga utas lain bangun, dan menggunakan kaedah pemberitahuan untuk membangunkan utas lain.

5. Kolam benang

Kolam benang ialah kaedah pengurusan benang biasa, yang membenarkan penggunaan semula benang dan meningkatkan kecekapan program. Fungsi Thread dalam Java menyediakan kelas ThreadPoolExecutor untuk melaksanakan kumpulan benang.

class MyTask implements Runnable {
    private Integer id;

    public MyTask(Integer id) {
        this.id = id;
    }

    public void run() {
        System.out.println("Task " + id + " is running");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任务
for (int i = 0; i < 10; i++) {
    executor.submit(new MyTask(i));
}

// 关闭线程池
executor.shutdown();

Dalam kod di atas, kami mencipta kumpulan benang dengan memanggil kaedah Pelaksana FixedThreadPool baharu, kemudian serahkan tugas, dan akhirnya tutup kumpulan benang.

Ringkasan

Fungsi Thread dalam Java menyediakan banyak kaedah untuk memudahkan operasi thread. Dalam pengaturcaraan sebenar, kita perlu memilih model benang yang berbeza mengikut keperluan kita sendiri, dan pada masa yang sama, kita mesti memberi perhatian kepada isu seperti penyegerakan benang dan kerjasama benang untuk memastikan ketepatan dan kecekapan operasi program.

Atas ialah kandungan terperinci Cara menggunakan fungsi Thread dalam Java untuk operasi thread. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!