深入理解Java Lambda表达式的返回与使用

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

// 定义一个函数式接口，用于等待某个操作完成
public interface Await {
    boolean await(long timeout, TimeUnit timeUnit) throws InterruptedException;
}

// 模拟服务器管理类
public class ServerManager {
    private CountDownLatch countDownLatch; // 假设已被初始化，用于等待服务器启动

    public ServerManager() {
        // 示例：初始化CountDownLatch，假设需要等待1个事件完成
        this.countDownLatch = new CountDownLatch(1);
    }

    // 启动服务器并返回一个Await实例
    public Await spinServerUp() {
        this.startServers(); // 启动服务器相关逻辑
        // 返回一个Lambda表达式，它实现了Await接口的await方法
        // 当这个Lambda被调用时，它会调用内部的countDownLatch.await()
        return (timeout, timeUnit) -> countDownLatch.await(timeout, timeUnit);
    }

    // 实际的服务器启动逻辑
    private void startServers() {
        System.out.println("Servers are starting in the background...");
        // 模拟服务器启动过程，并在完成后调用countDown()
        new Thread(() -> {
            try {
                // 模拟耗时操作
                Thread.sleep(2000);
                System.out.println("Server startup complete.");
                countDownLatch.countDown(); // 标记服务器启动完成
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println("Server startup interrupted.");
            }
        }).start();
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ServerManager manager = new ServerManager();
        // 调用spinServerUp()方法，获取返回的Lambda表达式（Await接口的实例）
        Await serverAwaiter = manager.spinServerUp();

        System.out.println("Main thread waiting for server startup to complete...");
        // 调用Lambda表达式实现的await方法，传入参数timeout和timeUnit
        boolean completed = serverAwaiter.await(5, TimeUnit.SECONDS);

        if (completed) {
            System.out.println("Server startup completed within the timeout. Application can proceed.");
        } else {
            System.out.println("Server startup did not complete within the timeout. Consider retrying or logging error.");
        }
    }
}

@FunctionalInterface
public interface ThingsToDo {
    void execute();
}

public class EventPlanner {
    public ThingsToDo planForBobArriving() {
        String personToCall = "Jack"; // 捕获局部变量 (effectively final)
        // 返回一个Lambda表达式，定义了当Bob到达时要执行的动作
        return () -> call(personToCall);
    }

    private void call(String person) {
        System.out.println("Calling " + person + " now...");
    }
}

public class MainLogic {
    private volatile boolean bobArrived = false; // 模拟Bob是否到达的状态

    public void setBobArrived(boolean bobArrived) {
        this.bobArrived = bobArrived;
    }

    public void executeMainFlow() {
        EventPlanner planner = new EventPlanner();
        // 获取当Bob到达时需要执行的动作
        ThingsToDo thingsToDoWhenBobArrived = planner.planForBobArriving();

        System.out.println("Waiting for Bob to arrive...");
        // 模拟持续等待Bob到达
        while (!bobArrived) {
            try {
                Thread.sleep(1000); // 模拟等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println("Main flow interrupted.");
                return;
            }
            System.out.println("Still waiting...");
        }

        // Bob到达了，执行预先计划好的动作
        System.out.println("Bob has arrived!");
        thingsToDoWhenBobArrived.execute(); // 执行“打电话给Jack”
    }

    public static void main(String[] args) throws InterruptedException {
        MainLogic logic = new MainLogic();
        // 模拟Bob在几秒后到达
        new Thread(() -> {
            try {
                Thread.sleep(3000); // 3秒后Bob到达
                logic.setBobArrived(true);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        logic.executeMainFlow();
    }
}