Kaedah penciptaan benang pengaturcaraan serentak Java:

1. Benang dan proses

Proses ialah aktiviti berjalan kod pada pengumpulan data Ia adalah unit asas peruntukan sumber dan penjadualan dalam sistem sekurang-kurangnya satu utas dalam proses , ialah unit asas penjadualan dan peruntukan CPU Berbilang rangkaian dalam proses berkongsi sumber proses.

Tiga ciri proses:

• Dinamik: Proses ialah program yang sedang berjalan dan perlu diduduki secara dinamik Sumber seperti memori, CPU dan rangkaian.

• Kemerdekaan: Proses adalah bebas antara satu sama lain dan mempunyai kawasan ingatan bebasnya sendiri.

• Konkurensi: Jika CPU ialah teras tunggal, sebenarnya terdapat hanya satu proses yang dilaksanakan dalam memori pada masa yang sama. CPU akan meninjau dan menukar dalam cara perkongsian masa untuk melayani setiap proses secara bergilir-gilir Oleh kerana kelajuan pensuisan adalah sangat pantas, ia memberi kita perasaan bahawa proses ini dilaksanakan pada masa yang sama.

2. Mencipta dan menjalankan utas

Kami mempunyai tiga cara untuk mencipta utas dalam satu proses:

• Kaedah 1: Mewarisi kelas Thread

• 1. Tentukan kelas thread untuk mewarisi kelas Thread.

• 2 Gantikan kaedah run()

• 3.

• 4. Panggil kaedah mula() objek utas untuk memulakan utas.

public class ThreadDemo {
    // 启动后的ThreadDemo当成一个进程。
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args) {
        // 3.创建一个线程对象
        Thread t = new MyThread();
        // 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！
        t.start();

        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("main线程输出："+i);
        }
    }
}

// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
    // 2.重写run()方法
    @Override
    public void run() {
        // 线程的执行方法。
        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("子线程输出："+i);
        }
    }
}

Kelebihan: Mudah untuk kod, cuma gunakan ini terus untuk mendapatkan thread semasa dalam kaedah run(), tanpa menggunakan kaedah Thread.currentThread() . Kelemahan: Kelas thread telah mewarisi kelas Thread dan tidak boleh mewarisi kelas lain, dan fungsi tidak boleh dikembangkan melalui warisan (had warisan tunggal). Selain itu, tugasan dan kod tidak dipisahkan Apabila berbilang benang melaksanakan tugas yang sama, berbilang kod tugasan diperlukan.

Ringkasan:

• Kelas thread ialah kelas yang mewarisi Thread.

• Kaedah mula() mesti dipanggil untuk memulakan utas.

• Berbilang benang serentak mendahului pelaksanaan CPU, jadi rawak serentak akan berlaku semasa pelaksanaan

Kaedah 2: Cara untuk melaksanakan antara muka Runnable.

• 1 Buat kelas tugasan benang untuk melaksanakan antara muka Runnable.

• 2 Gantikan kaedah run()

• 3.

• 4 Pek objek tugasan benang ke dalam objek benang

• 5. Panggil kaedah mula() objek benang untuk memulakan benang.

public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)
        Runnable target = new MyRunnable();
        // 4.把线程任务对象包装成线程对象.且可以指定线程名称
        // Thread t = new Thread(target);
        Thread t = new Thread(target,"1号线程");
        // 5.调用线程对象的start()方法启动线程
        t.start();

        Thread t2 = new Thread(target);
        // 调用线程对象的start()方法启动线程
        t2.start();

        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}

// 1.创建一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
    // 2.重写run()方法
    @Override
    public void run() {
        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}

Kelebihan:

Kelas tugas benang hanya melaksanakan antara muka Runnable, boleh terus mewarisi kelas lain dan boleh terus melaksanakan kelas lain antara muka (elakkan (di luar batasan warisan tunggal). Objek tugasan benang yang sama boleh dibungkus ke dalam berbilang objek benang, sesuai untuk berbilang benang untuk berkongsi sumber yang sama. Untuk mencapai operasi penyahgandingan, kod tugasan benang boleh dikongsi oleh berbilang benang, dan kod tugasan benang dan benang adalah bebas.

Kaedah 3: Laksanakan antara muka Boleh Panggil

• 1. Tentukan kelas tugasan benang untuk melaksanakan antara muka Boleh Panggil dan mengisytiharkan jenis urutan hasil perlaksanaan.

• 2 Tulis semula kaedah panggilan kelas tugas benang Kaedah ini boleh mengembalikan hasil pelaksanaan secara langsung.

• 3. Cipta objek tugas benang Boleh Panggil.

• 4 Pek objek tugas benang Boleh Panggil ke dalam objek FutureTask.

• 5 Pek objek FutureTask ke dalam objek benang.

• 6 Panggil kaedah mula () utas untuk memulakan utas.

public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个Callable的线程任务对象
        Callable call = new MyCallable();
        // 4.把Callable任务对象包装成一个未来任务对象
        //      -- public FutureTask(Callable<V> callable)
        // 未来任务对象是啥，有啥用？
        //      -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
        //      -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
        FutureTask<String> task = new FutureTask<>(call);
        // 5.把未来任务对象包装成线程对象
        Thread t = new Thread(task);
        // 6.启动线程对象
        t.start();

        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
        }

        // 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
        try {
            String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
            System.out.println(rs);
        }  catch (Exception e) {
            e.printStackTrace();
        }

    }
}

// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable<String>{
    // 2.重写线程任务类的call方法！
    @Override
    public String call() throws Exception {
        // 需求：计算1-10的和返回
        int sum = 0 ;
        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
            sum+=i;
        }
        return Thread.currentThread().getName()+"执行的结果是："+sum;
    }
}

Kelebihan: Kelas tugas benang hanya melaksanakan antara muka Boleh Panggil, boleh terus mewarisi kelas lain dan boleh terus melaksanakan antara muka lain (mengelakkan pengehadan warisan tunggal). Objek tugas benang yang sama boleh dibungkus ke dalam berbilang objek benang, sesuai untuk berbilang benang untuk berkongsi sumber yang sama. Untuk mencapai operasi penyahgandingan, kod tugasan benang boleh dikongsi oleh berbilang benang, dan kod tugasan benang dan benang adalah bebas. Perkara yang paling penting ialah dapat terus mendapatkan hasil pelaksanaan benang.

Atas ialah kandungan terperinci Kaedah penciptaan benang pengaturcaraan serentak Java:. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!