Java 中实现异步的多种方式_Java

在 java 中实现异步处理有多种方式，每种方式都有其特定的适用场景和优缺点。以下是几种常见的实现异步处理的方式：

1. 线程池（executorservice）

简介：使用 executorservice 可以创建线程池来执行异步任务。
优点：资源复用、线程管理方便。
缺点：需要手动管理线程池的生命周期。
示例：

import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
public class threadpoolexample {
    public static void main(string[] args) {
        executorservice executor = executors.newfixedthreadpool(2);
        runnable task1 = () -> {
            system.out.println("task 1 running in thread: " + thread.currentthread().getname());
        };
        runnable task2 = () -> {
            system.out.println("task 2 running in thread: " + thread.currentthread().getname());
        };
        executor.execute(task1);
        executor.execute(task2);
        executor.shutdown();
    }
}

2. completablefuture

简介：completablefuture 是 java 8 引入的一个强大的异步编程工具，支持链式调用和组合操作。
优点：功能丰富、易于组合多个异步操作。
缺点：学习曲线较陡峭。
示例：

import java.util.concurrent.completablefuture;
public class completablefutureexample {
    public static void main(string[] args) {
        completablefuture.supplyasync(() -> {
            system.out.println("task 1 running in thread: " + thread.currentthread().getname());
            return "result 1";
        }).thenapply(result -> {
            system.out.println("task 2 running in thread: " + thread.currentthread().getname());
            return result + " processed";
        }).thenaccept(finalresult -> {
            system.out.println("final result: " + finalresult);
        });
        // 防止主线程提前结束
        try {
            thread.sleep(1000);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
    }
}

3. forkjoinpool

简介：forkjoinpool 是一个特殊的线程池，适用于可以分解成多个子任务并行处理的场景。
优点：适合处理大量细粒度的任务。
缺点：适用于特定类型的任务，不适用于所有异步场景。
示例：

import java.util.concurrent.forkjoinpool;
import java.util.concurrent.recursivetask;
public class forkjoinexample extends recursivetask<integer> {
    private final int threshold = 2;
    private final int start;
    private final int end;
    public forkjoinexample(int start, int end) {
        this.start = start;
        this.end = end;
    }
    @override
    protected integer compute() {
        if (end - start <= threshold) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += i;
            }
            return sum;
        } else {
            int middle = (start + end) / 2;
            forkjoinexample subtask1 = new forkjoinexample(start, middle);
            forkjoinexample subtask2 = new forkjoinexample(middle, end);
            subtask1.fork();
            subtask2.fork();
            return subtask1.join() + subtask2.join();
        }
    }
    public static void main(string[] args) {
        forkjoinpool pool = new forkjoinpool();
        forkjoinexample task = new forkjoinexample(1, 100);
        int result = pool.invoke(task);
        system.out.println("result: " + result);
    }
}

4. callable 和future

简介：callable 是一个可以返回结果并可能抛出异常的任务，future 用于获取 callable 的执行结果。
优点：可以获取任务的执行结果。
缺点：需要手动管理线程和任务的生命周期。
示例：

import java.util.concurrent.callable;
import java.util.concurrent.executionexception;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;
public class callablefutureexample {
    public static void main(string[] args) {
        executorservice executor = executors.newsinglethreadexecutor();
        callable<integer> task = () -> {
            thread.sleep(2000);
            return 42;
        };
        future<integer> future = executor.submit(task);
        try {
            integer result = future.get();
            system.out.println("result: " + result);
        } catch (interruptedexception | executionexception e) {
            e.printstacktrace();
        }
        executor.shutdown();
    }
}

5. scheduledexecutorservice

简介：scheduledexecutorservice 是一个可以调度延迟任务和周期性任务的线程池。
优点：适合定时任务和周期性任务。
缺点：功能相对单一。
示例：

import java.util.concurrent.executors;
import java.util.concurrent.scheduledexecutorservice;
import java.util.concurrent.timeunit;
public class scheduledexecutorexample {
    public static void main(string[] args) {
        scheduledexecutorservice scheduler = executors.newscheduledthreadpool(1);
        runnable task = () -> {
            system.out.println("task running in thread: " + thread.currentthread().getname());
        };
        // 延迟2秒后执行任务
        scheduler.schedule(task, 2, timeunit.seconds);
        // 每隔1秒执行一次任务
        scheduler.scheduleatfixedrate(task, 0, 1, timeunit.seconds);
        // 防止主线程提前结束
        try {
            thread.sleep(10000);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        scheduler.shutdown();
    }
}