Bagaimana untuk melaksanakan pengaturcaraan tak segerak di Java

Cara melaksanakan pengaturcaraan tak segerak dalam Java

Pengenalan:
Dengan perkembangan pesat Internet, terdapat lebih banyak keperluan untuk konkurensi tinggi dan prestasi tinggi, dan model pengaturcaraan segerak tradisional tidak lagi dapat memenuhi permintaan ini. Model pengaturcaraan tak segerak mempunyai kelebihan dalam menyelesaikan masalah konkurensi tinggi dan prestasi tinggi, dan boleh meningkatkan daya pemprosesan dan kelajuan tindak balas program. Artikel ini akan memperkenalkan cara melaksanakan pengaturcaraan tak segerak dalam Java dan menyediakan contoh kod khusus.

1. Gunakan kumpulan benang untuk melaksanakan pengaturcaraan tak segerak
Java menyediakan kumpulan benang (ThreadPoolExecutor) untuk mengurus penggunaan semula dan penjadualan benang, yang boleh melaksanakan pengaturcaraan tak segerak dengan mudah. Dengan menyerahkan tugasan kepada kumpulan benang, kumpulan benang akan menetapkan benang kepada setiap tugasan untuk pelaksanaan dan mengembalikan objek Masa Depan untuk mendapatkan hasil pelaksanaan tugas.

Berikut ialah kod contoh ringkas yang menunjukkan cara menggunakan kumpulan benang untuk melaksanakan pengaturcaraan tak segerak:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        Future<String> future = executorService.submit(() -> {
            // 模拟耗时任务
            Thread.sleep(3000);
            return "Hello, World!";
        });
        
        // 异步获取任务的执行结果
        try {
            String result = future.get();
            System.out.println("任务执行结果：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        executorService.shutdown();
    }
}

Dalam kod sampel di atas, tugas Boleh Panggil diserahkan melalui kaedah submit() ExecutorService, dan tugas itu akan dalam pelaksanaan utas baharu. Objek masa hadapan digunakan untuk mendapatkan hasil pelaksanaan tugas. Apabila memanggil kaedah future.get(), jika tugasan telah selesai, hasilnya akan dikembalikan serta-merta jika tugasan belum selesai, ia akan menyekat dan menunggu sehingga tugasan selesai.

2. Gunakan CompletableFuture untuk melaksanakan pengaturcaraan tak segerak
Java 8 memperkenalkan kelas CompletableFuture, yang menyediakan fungsi pengaturcaraan tak segerak yang lebih kaya. CompletableFuture menyediakan satu siri kaedah untuk menggabungkan berbilang tugas tak segerak dalam rantai, dan menyokong pengendalian pengecualian, kawalan tamat masa dan ciri lain.

Berikut ialah contoh kod yang menggunakan CompletableFuture untuk melaksanakan pengaturcaraan tak segerak:

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureDemo {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟耗时任务
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello, World!";
        });
        
        // 异步获取任务的执行结果
        future.thenAccept(result -> {
            System.out.println("任务执行结果：" + result);
        });
        
        // 阻塞等待任务完成
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Dalam kod sampel di atas, tugas Pembekal diserahkan melalui kaedah supplyAsync() CompletableFuture, dan tugasan itu akan dilaksanakan dalam urutan baharu. Gunakan kaedah thenAccept() untuk mengendalikan hasil pelaksanaan tugas, yang akan dipanggil apabila tugasan selesai. Panggil kaedah future.get() untuk menyekat menunggu tugasan selesai.

3. Gunakan fungsi panggil balik untuk melaksanakan pengaturcaraan tak segerak
Selain menggunakan kumpulan benang dan CompletableFuture, anda juga boleh menggunakan fungsi panggil balik (Callback) untuk melaksanakan pengaturcaraan tak segerak. Prinsip fungsi panggil balik adalah untuk menghantar fungsi (fungsi panggil balik) sebagai parameter kepada fungsi lain Apabila peristiwa atau keadaan tertentu berlaku, fungsi yang dipanggil akan dilaksanakan.

Berikut ialah contoh kod yang menggunakan fungsi panggil balik untuk melaksanakan pengaturcaraan tak segerak:

public class CallbackDemo {
    public static void main(String[] args) {
        Worker worker = new Worker();
        worker.doWork("Hello, World!", result -> {
            System.out.println("任务执行结果：" + result);
        });
    }
}

interface Callback {
    void onComplete(String result);
}

class Worker {
    public void doWork(String data, Callback callback) {
        new Thread(() -> {
            // 模拟耗时任务
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            String result = data.toUpperCase();
            
            // 异步回调
            callback.onComplete(result);
        }).start();
    }
}

Dalam kod sampel di atas, kaedah doWork() dalam kelas Worker akan melaksanakan tugas yang memakan masa dalam urutan baharu dan menghantarnya selepas tugas selesai Fungsi panggil balik memberitahu keputusan secara tidak segerak. Apabila memanggil kaedah worker.doWork() dalam CallbackDemo, fungsi panggil balik tanpa nama dihantar sebagai parameter melalui ungkapan Lambda.

Kesimpulan:
Java menyediakan pelbagai cara untuk melaksanakan pengaturcaraan tak segerak, termasuk kumpulan benang, CompletableFuture, fungsi panggil balik, dsb. Bergantung pada keperluan dan senario sebenar, memilih kaedah yang sesuai untuk melaksanakan pengaturcaraan tak segerak boleh meningkatkan prestasi dan kelajuan tindak balas program. Apabila menulis kod tak segerak, anda juga perlu memberi perhatian kepada isu seperti pengendalian pengecualian dan keselamatan benang untuk memastikan kebolehpercayaan dan kestabilan kod. Dengan menggunakan pengaturcaraan tak segerak secara rasional, sumber sistem boleh digunakan sepenuhnya dan keupayaan pemprosesan serentak sistem boleh dipertingkatkan.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan pengaturcaraan tak segerak di Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!