Bagaimana untuk membuat dan menjalankan benang dalam Java?

1. Lima cara untuk mencipta dan menjalankan utas

Cara pertama: mewarisi kelas Thread

Kaedah ini adalah yang paling asas Rakan-rakan yang pernah belajar Java semua tahu kaedah ini, jadi saya tidak akan menjelaskan secara terperinci. Perlu diingatkan bahawa: Pelaksanaan tindanan menggunakan kaedah larian dan utas larian menggunakan kaedah mula.

public class FirstWay extends Thread  {
    @Override
    public void run() {
        System.out.println("第一种实现线程的方式:继承Thread类");
    }
    //模拟测试
    public static void main(String[] args) {
        new FirstWay().start();
    }
}

Kedua: Laksanakan antara muka Runnable

Kaedah pelaksanaan kedua masih sangat asas Ia mewarisi antara muka Runnable dan menulis semula kaedah run untuk melaksanakan logik runnable. Nota: benang yang sedang berjalan perlu ditutup dengan lapisan new Thread.

public class SecondWay implements Runnable{
    @Override
    public void run() {
        System.out.println("第二种实现线程的方式:实现Runnable接口");
    }
    //模拟测试
    public static void main(String[] args) {
        new Thread(new SecondWay()).start();
    }
}

Cara ketiga: laksanakan antara muka Boleh Panggil

Cara ketiga ialah melaksanakan antara muka Boleh Panggil dan antara muka Boleh Panggil boleh melaksanakan utas.

public class ThirdWay implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("第三种实现线程的方式:实现Callable接口");
        return "Callable接口带返回值，可以抛出异常";
    }

    //模拟测试
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new ThirdWay());
        new Thread(futureTask).start();
        //阻塞方法，获取call方法返回值
        System.out.println(futureTask.get());  //打印：Callable接口带返回值，可以抛出异常
    }
}

Perbezaannya adalah seperti berikut:

• Kaedah utas yang dilaksanakan oleh antara muka Boleh Panggil ialah panggilan, dan kaedah utas dilaksanakan oleh antara muka Boleh Dijalankan dijalankan

• Boleh Dipanggil mempunyai nilai pulangan, tetapi antara muka Boleh Dijalankan tidak boleh mempunyai nilai pulangan

• Nilai pulangan panggilan kaedah antara muka boleh dipanggil boleh ditetapkan kepada jenis generik, jenis data String digunakan dalam contoh berikut

• Kaedah panggilan boleh panggil kaedah antara muka boleh membuang pengecualian, Kaedah runable antara muka tidak boleh membuang pengecualian

• Kaedah antara muka boleh panggil dijalankan melalui new Thread(futureTask).start(), Kaedah get FutureTask boleh mendapatkan nilai pulangan kaedah panggilan kaedah antara muka Boleh Panggil

• Jika kaedah panggilan kaedah antara muka Boleh Panggil adalah tidak normal, pengecualian yang sama akan dilemparkan apabila kaedah get FutureTask dipanggil

Kaedah keempat: kumpulan benang + jalankan

Bermula dari versi JDK5, java menyediakan sokongan kumpulan benang secara lalai Menjalankan utas dalam kumpulan benang boleh mengelakkan rangkaian tanpa had menyebabkan masa henti aplikasi, tetapi juga menjimatkan sumber dan kos masa pembuatan dan pemusnahan benang yang kerap.

public class FourthWay implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +
                ":实现线程的方式Runnable接口,但运行方式不一样，使用线程池");
    }

    public static void main(String[] args) {
        //创建一个固定大小的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        for(int i = 0;i < 10;i++){
            threadPool.execute(new FourthWay());
        }
    }
}

ExecutorService pool thread menggunakan kaedah laksana untuk menjalankan pelaksanaan thread kaedah run antara muka Runnable Ciri umum kaedah execute dan kaedah run ialah tiada nilai pulangan.

pool-1-thread-5:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-2:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-4:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-4:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-4:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-1:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-4:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-3:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-2:实现线程的方式Runnable接口,但运行方式不一样，使用线程池
pool-1-thread-5:实现线程的方式Runnable接口,但运行方式不一样，使用线程池

Seperti yang dapat dilihat daripada keputusan di atas, kumpulan benang mengandungi lima utas. Selepas benang selesai, ia tidak dimusnahkan, tetapi dikembalikan ke kumpulan benang Sumber benang diperoleh daripada kumpulan benang dan dijalankan semula semasa pelaksanaan seterusnya.

Jenis kelima: kumpulan benang + hantar

Contoh kumpulan benang berikut ExecutorService menggunakan kaedah serah untuk menjalankan pelaksanaan urutan kaedah panggilan antara muka Boleh Panggil kaedah hantar dan kaedah panggilan adalah Terdapat nilai pulangan.

• Nilai pulangan kaedah panggilan antara muka Boleh Panggil boleh ditakrifkan oleh generik

• Nilai pulangan kumpulan utas ExecutorService yang diserahkan kaedah ialah Masa Depan

Kaedah get Masa Depan boleh mendapatkan nilai pulangan kaedah panggilan, dan jika kaedah panggilan membuang pengecualian, kaedah dapatkan Masa Depan juga akan membuang pengecualian.

public class FifthWay implements Callable<String> {
    @Override
    public String call() throws Exception {
        return Thread.currentThread().getName() + ":Callable接口带返回值，可以抛出异常";
    }

    //模拟测试
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //保存多线程执行结果
        List<String> retList = new ArrayList<>();
        //创建一个固定大小的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        for(int i = 0;i < 10;i++){
            Future<String> future = threadPool.submit(new FifthWay());
            retList.add(future.get());
        }
        //java8 语法，打印retlist
        retList.forEach(System.out::println);
    }
}

Terdapat gula sintaks kecil dalam kod di atas, retList.forEach(System.out::println); ialah rujukan kaedah yang disediakan oleh java8

pool-1-thread-1:Callable接口带返回值，可以抛出异常
pool-1-thread-2:Callable接口带返回值，可以抛出异常
pool-1-thread-3:Callable接口带返回值，可以抛出异常
pool-1-thread-4:Callable接口带返回值，可以抛出异常
pool-1-thread-5:Callable接口带返回值，可以抛出异常
pool-1-thread-1:Callable接口带返回值，可以抛出异常
pool-1-thread-2:Callable接口带返回值，可以抛出异常
pool-1-thread-3:Callable接口带返回值，可以抛出异常
pool-1-thread-4:Callable接口带返回值，可以抛出异常
pool-1-thread-5:Callable接口带返回值，可以抛出异常

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