java并发、异步以及函数式

October 10, 2022

java

见：多线程实用库函数式

文档：java.util.concurrent java.util.function

java.util.function

提供一些可以表示 lambda 函数的类型的泛型接口
根据命名，有以下几种类型：

Function<T,R> ( T -> R 的一元函数)
Consumer<T> ( T -> void 的一元函数)
Predicate<T> (T -> boolean 的一元函数)
Supplier<T> (返回 R 的无参函数)
UnaryOperator<T> (T -> T 的一元函数)

以Function<T,R>为例，实际的方法函数就是 Function::apply 这个函数

令这个函数为 f ，另一函数为 g
则 compose 方法为 f(g())，andThen 方法为 g(f())

此外

Runnable (void -> void)
Callable<V> (void -> V)

java

// 很容易定义这种函数式接口
@FunctionalInterface
public interface Runnable {
    void run();
}

java

@FunctionalInterface
public interface Function<T, R> {
    R apply(T var1);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (v) -> {
            return this.apply(before.apply(v));
        };
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (t) -> {
            return after.apply(this.apply(t));
        };
    }

    static <T> Function<T, T> identity() {
        return (t) -> {
            return t;
        };
    }
}

java 本身没有 Functor 类，但存在Optional 类作为容器类型。Stream 包中也存在其它的容器，但存储流而非单个值了。

java.util.concurrent

Callable Future FutureTask

java

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

java

public interface Future<V> {
    boolean cancel(boolean var1);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long var1, TimeUnit var3) throws InterruptedException, ExecutionException, TimeoutException;
}

java

FutureTask task = new FutureTask((Callable<Integer>) () -> 123);
Thread t1 = new Thread(task);
t1.start();
System.out.println(task.get()); // 123

CompletableFuture

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/CompletableFuture.html

←Back to home

This work is licensed under CC BY-NC-SA 4.0