int result = calculateSum(3, 5); // 等到函數(shù)調(diào)用完成后，獲取返回結(jié)果
System.out.println(result);      // 輸出計(jì)算結(jié)果 8

public static int calculateSum(int a, int b) {
    // 同步調(diào)用：當(dāng)前線程會(huì)阻塞，直到函數(shù)計(jì)算完成并返回結(jié)果
    return a + b;
}

interface Callback {
    void onComplete(int result);
}

void calculateSumAsync(int a, int b, Callback callback) {
    new Thread(() -> {
        int result = a + b;
        callback.onComplete(result); // 完成后通知調(diào)用者
    }).start();
}

// 調(diào)用
calculateSumAsync(3, 5, (result) -> System.out.println("結(jié)果: " + result));

class EventEmitter {
    private List<EventListener> listeners = new ArrayList<>();

    void addListener(EventListener listener) {
        listeners.add(listener);
    }

    void doWork() {
        new Thread(() -> {
            int result = 42;
            for (EventListener listener : listeners) {
                listener.onEvent(result); // 觸發(fā)事件
            }
        }).start();
    }
}

interface EventListener {
    void onEvent(int data);
}

// 調(diào)用
EventEmitter emitter = new EventEmitter();
emitter.addListener(data -> System.out.println("收到事件: " + data));
emitter.doWork();

// BIO 服務(wù)端：阻塞式接收 + 阻塞式讀取（一個(gè)連接一個(gè)線程示例）
import java.io.*;
import java.net.*;

public class BioServer {
    public static void main(String[] args) throws Exception {
        ServerSocket server = new ServerSocket(8080);
        System.out.println("BIO server start...");

        while (true) {
            Socket socket = server.accept(); // 阻塞：等待連接
            new Thread(() -> {
                try (BufferedReader in = new BufferedReader(
                        new InputStreamReader(socket.getInputStream()));
                     PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {

                    String line = in.readLine(); // 阻塞：等待數(shù)據(jù)
                    out.println("BIO reply: " + line);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

// NIO 服務(wù)端：Selector 多路復(fù)用（單線程處理多個(gè)連接）
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class NioServer {
    public static void main(String[] args) throws Exception {
        ServerSocketChannel server = ServerSocketChannel.open();
        server.bind(new InetSocketAddress(8081));
        server.configureBlocking(false);

        Selector selector = Selector.open();
        server.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("NIO server start...");

        ByteBuffer buf = ByteBuffer.allocate(1024);

        while (true) {
            selector.select(); // 阻塞等待“就緒事件”（可認(rèn)為等待通知）
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();

            while (it.hasNext()) {
                SelectionKey key = it.next();
                it.remove();

                if (key.isAcceptable()) {
                    SocketChannel sc = server.accept();
                    sc.configureBlocking(false);
                    sc.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    SocketChannel sc = (SocketChannel) key.channel();
                    buf.clear();
                    int n = sc.read(buf); // 非阻塞讀：可能返回 0 或 -1
                    if (n <= 0) {
                        sc.close();
                        continue;
                    }
                    buf.flip();
                    sc.write(ByteBuffer.wrap(("NIO reply: ").getBytes()));
                    sc.write(buf);
                }
            }
        }
    }
}

// AIO 服務(wù)端：異步 accept + 異步 read（回調(diào)驅(qū)動(dòng)）
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.concurrent.CountDownLatch;

public class AioServer {
    public static void main(String[] args) throws Exception {
        AsynchronousServerSocketChannel server =
                AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(8082));

        System.out.println("AIO server start...");

        CountDownLatch latch = new CountDownLatch(1);

        server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel ch, Void att) {
                // 繼續(xù)接收下一個(gè)連接（非常關(guān)鍵，否則只接一次）
                server.accept(null, this);

                ByteBuffer buf = ByteBuffer.allocate(1024);
                ch.read(buf, buf, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer n, ByteBuffer b) {
                        try {
                            if (n <= 0) { ch.close(); return; }
                            b.flip();
                            ch.write(ByteBuffer.wrap("AIO reply: ".getBytes())).get();
                            ch.write(b).get();
                            ch.close();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    @Override
                    public void failed(Throwable exc, ByteBuffer b) {
                        try { ch.close(); } catch (Exception ignored) {}
                    }
                });
            }

            @Override
            public void failed(Throwable exc, Void att) {
                exc.printStackTrace();
                latch.countDown();
            }
        });

        latch.await(); // 防止主線程退出
    }
}