Netty从0到1系列之Promise

---

推荐阅读:

【01】Netty从0到1系列之I/O模型
【02】Netty从0到1系列之NIO
【03】Netty从0到1系列之Selector
【04】Netty从0到1系列之Channel
【05】Netty从0到1系列之Buffer(上)
【06】Netty从0到1系列之Buffer(下)
【07】Netty从0到1系列之零拷贝技术
【08】Netty从0到1系列之整体架构、入门程序
【09】Netty从0到1系列之EventLoop
【10】Netty从0到1系列之EventLoopGroup
【11】Netty从0到1系列之Future

一、Promise

1.1 Promise是什么?

Promise 是 Netty 异步编程模型中的核心组件，它代表一个可写的异步操作结果。与普通的 Future 不同，Promise 提供了主动设置操作结果（成功或失败）的能力，使得开发者可以手动控制异步操作的完成状态。

在 Netty 的异步编程模型中，Promise 是最核心、最灵活的组件之一。它是 Future 的可写版本，代表一个“尚未完成但可被设置结果的承诺”。你可以将其理解为：“我承诺将来会给你一个结果，而我（或某个操作）可以决定这个结果是成功还是失败。”

Promise 的核心特性：

• 可写性：可以主动设置操作的成功结果或失败原因
• 异步结果容器：承载异步操作的结果值或异常信息
• 监听器通知：支持添加监听器，在结果设置时自动通知
• 状态一致性：保证结果只能被设置一次，确保状态一致性
• 线程安全：所有操作都是线程安全的

🌟 核心职责：

• 创建一个可被设置结果的“未来”
• 将异步操作的结果“承诺”给调用者
• 实现异步操作的“生产者-消费者”模型

💡 关键特性：

• Promise 是 可写的 Future
• 一旦设置结果，不可更改
• 可以添加监听器，实现回调驱动

1.2 Promise 的继承体系与核心方法

Promise 在 Netty 的继承体系中的位置如下：

io.netty.util.concurrent.Future<V>
    -> Promise<V> (扩展了结果设置能力)
        -> ChannelPromise (扩展了Channel相关功能)
            -> DefaultChannelPromise (主要实现)
    
io.netty.util.concurrent.Promise<V>
    -> DefaultPromise (基础实现)

为了更好地理解 Promise 的状态转换和工作原理，请看下面的状态图：

接口定义:

public interface Promise<V> extends Future<V> {

    /**
     * 设置成功结果
     */
    Promise<V> setSuccess(V result);

    /**
     * 尝试设置成功结果（线程安全）
     */
    boolean trySuccess(V result);

    /**
     * 设置失败原因
     */
    Promise<V> setFailure(Throwable cause);

    /**
     * 尝试设置失败原因（线程安全）
     */
    boolean tryFailure(Throwable cause);

    /**
     * 标记为不可取消（一旦调用，无法取消）
     */
    boolean setUncancellable();

    /**
     * 返回关联的 EventExecutor（执行监听器的线程）
     */
    @Override
    EventExecutor executor();
}

✅ 核心方法：

• setSuccess() / setFailure()：设置最终结果
• trySuccess() / tryFailure()：原子性尝试设置，避免重复设置
• setUncancellable()：防止被取消

1.3 Promise与Future的关系

Promise 与 Future 的关系是 Netty 异步模型的基础：

• Future：只读视图，只能查询状态和获取结果
• Promise：可写视图，除了 Future 的功能外，还能设置结果、异常或取消操作

1.4 Promise 的底层实现原理

1.4.1 ✅ DefaultPromise 核心机制

DefaultPromise 是 Promise 的默认实现类，其核心机制包括：

• ✅ 状态机（State Machine）

• 一旦状态变更（成功/失败/取消），不可逆
• 保证“承诺”的唯一性和确定性
  • 使用 volatile int state 表示状态
  • 状态变更通过 CAS 操作保证原子性

// DefaultPromise 的核心状态管理（简化版）
public class DefaultPromise<V> implements Promise<V> {
    // 结果对象：null表示未完成，SUCCESS常量表示成功，其他表示具体结果或异常
    private volatile Object result;
    
    // 监听器列表
    private Object listeners;
    
    // 执行器，用于在正确的线程中执行监听器
    private final EventExecutor executor;
    
    private static final Object SUCCESS = new Object();
    private static final Object UNCANCELLABLE = new Object();
    
    @Override
    public Promise<V> setSuccess(V result) {
        if (setSuccess0(result)) {
            notifyListeners();
            return this;
        }
        throw new IllegalStateException("操作已完成: " + this);
    }
    
    private boolean setSuccess0(V result) {
        // 使用CAS操作确保原子性
        if (RESULT_UPDATER.compareAndSet(this, null, result == null ? SUCCESS : result)) {
            return true;
        }
        return false;
    }
    
    @Override
    public Promise<V> setFailure(Throwable cause) {
        if (setFailure0(cause)) {
            notifyListeners();
            return this;
        }
        throw new IllegalStateException("操作已完成: " + this);
    }
    
    private boolean setFailure0(Throwable cause) {
        // 使用CAS操作确保原子性
        if (RESULT_UPDATER.compareAndSet(this, null, cause)) {
            return true;
        }
        return false;
    }
    
    private void notifyListeners() {
        // 在正确的线程中执行监听器
        if (executor.inEventLoop()) {
            notifyListenersNow();
        } else {
            executor.execute(this::notifyListenersNow);
        }
    }
}

• ✅ 监听器通知机制

内部维护一个 GenericFutureListener 列表

• 当 setSuccess() 或 setFailure() 被调用时：
  • 更新状态和结果
  • 遍历监听器列表
  • 在 EventExecutor 线程中异步执行每个监听器的 operationComplete() 方法

public class DefaultPromise<V> implements Promise<V> {
    private void notifyListenersNow() {
        Object listeners = this.listeners;
        if (listeners == null) {
            return;
        }
        
        // 处理不同类型的监听器存储
        if (listeners instanceof GenericFutureListener) {
            notifyListener0((GenericFutureListener<?>) listeners);
        } else if (listeners instanceof DefaultFutureListeners) {
            notifyListeners0((DefaultFutureListeners) listeners);
        } else {
            for (GenericFutureListener<?> l : (GenericFutureListener<?>[]) listeners) {
                notifyListener0(l);
            }
        }
    }
    
    private void notifyListener0(GenericFutureListener<?> listener) {
        try {
            // 调用监听器
            listener.operationComplete(this);
        } catch (Throwable t) {
            // 监听器异常不影响其他监听器
            System.err.println("监听器执行异常: " + t.getMessage());
        }
    }
    
    @Override
    public Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> listener) {
        synchronized (this) {
            addListener0(listener);
        }
        
        // 如果已经完成，立即通知新添加的监听器
        if (isDone()) {
            notifyListener0(listener);
        }
        return this;
    }
}

✅ 线程安全保证：

• result 和 state 使用 volatile 修饰

• 使用 synchronized 或 CAS 操作保护状态变更
• 监听器执行与状态变更解耦

• ✅ 内存可见性
  • 使用 volatile 关键字确保状态和结果的内存可见性
  • 避免多线程环境下的缓存不一致问题

1.4.2 与 EventLoop 的协同

• Promise 绑定到特定的 EventExecutor（通常是 EventLoop）
• 所有监听器在该 EventExecutor 的线程中执行
• 保证无锁串行化，避免竞态条件

// 创建 Promise 时指定 Executor
Promise<String> promise = new DefaultPromise<>(eventLoop);

1.5 Promise 的核心 API 与用法

1.5.1 基础Promise使用

package cn.tcmeta.future;

import io.netty.util.concurrent.*;

import java.util.concurrent.TimeUnit;

/**
 * 演示 Promise 的基本用法
 */
public class PromiseBasicExample {

    public static void main(String[] args) throws Exception {
        // 创建 EventExecutor（模拟 EventLoop）
        EventExecutorGroup group = new DefaultEventExecutorGroup(2);
        EventExecutor executor = group.next();

        try {
            // 创建一个 Promise
            Promise<String> promise = new DefaultPromise<>(executor);

            // 调用者获取 Future（只读视图）
            Future<String> future = promise;

            // 添加监听器（回调）
            future.addListener((GenericFutureListener<Future<String>>) f -> {
                if (f.isSuccess()) {
                    System.out.println("✅ 任务成功: " + f.get());
                } else {
                    System.err.println("❌ 任务失败: " + f.cause().getMessage());
                }
            });

            // 模拟异步任务执行（生产者）
            executor.execute(() -> {
                try {
                    Thread.sleep(1000); // 模拟耗时操作
                    if (Math.random() > 0.3) {
                        promise.setSuccess("任务执行完毕");
                    } else {
                        promise.setFailure(new RuntimeException("任务执行失败"));
                    }
                } catch (Exception e) {
                    promise.setFailure(e);
                }
            });

            // 等待完成
            future.await(3, TimeUnit.SECONDS);

        } finally {
            group.shutdownGracefully();
        }
    }
}

1.5.2 Promise 的可写性与线程安全

trySuccess, trySuccess 是线程安全的，只会有一个成功;

package cn.tcmeta.promise;

import io.netty.util.concurrent.*;

import java.util.concurrent.TimeUnit;

/**
 * 演示 Promise 的线程安全与 trySuccess
 */
public class PromiseThreadSafetyExample {

    public static void main(String[] args) throws Exception {
        EventExecutor executor = new DefaultEventExecutor();
        // 共享的 Promise
        Promise<String> promise = new DefaultPromise<>(executor);

        // 启动多个线程尝试设置结果
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.execute(() -> {
                // trySuccess 是线程安全的，只会有一个成功
                boolean success = promise.trySuccess("Task-" + taskId + " 完成");
                if (success) {
                    System.out.println("🏆 Task-" + taskId + " 成功设置结果");
                } else {
                    System.out.println("❌ Task-" + taskId + " 设置失败（已被其他线程设置）");
                }
            });
        }

        // 添加监听器
        promise.addListener((GenericFutureListener<Promise<String>>) f -> {
            if (f.isSuccess()) {
                System.out.println("🎉 最终结果: " + f.get());
            }
        });

        // 等待
        promise.await(2, TimeUnit.SECONDS);
        executor.shutdownGracefully();
    }
}

1.5.3 Promise 实现自定义异步操作

package cn.tcmeta.promise;

import io.netty.util.concurrent.*;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 模拟一个异步缓存服务
 */
public class AsyncCacheService {

    private final ConcurrentHashMap<String, String> cache = new ConcurrentHashMap<>();
    private final EventExecutor executor;
    private final AtomicLong taskId = new AtomicLong(0);

    public AsyncCacheService(EventExecutor executor) {
        this.executor = executor;
    }

    /**
     * 异步获取缓存值
     *
     * @param key 键
     * @return Promise，结果可用时通知
     */
    public Promise<String> getAsync(String key) {
        DefaultPromise<String> promise = new DefaultPromise<>(executor);

        executor.execute(() -> {
            try {
                Thread.sleep(200); // 模拟延迟
                String value = cache.get(key);
                if (value != null) {
                    promise.setSuccess(value);
                } else {
                    promise.setFailure(new RuntimeException("Key not found: " + key));
                }
            } catch (Exception e) {
                promise.setFailure(e);
            }
        });

        return promise;
    }

    /**
     * 异步设置缓存值
     */
    public Promise<Void> setAsync(String key, String value) {
        DefaultPromise<Void> promise = new DefaultPromise<>(executor);

        executor.execute(() -> {
            try {
                Thread.sleep(100);
                cache.put(key, value);
                promise.setSuccess(null);
            } catch (Exception e) {
                promise.setFailure(e);
            }
        });

        return promise;
    }

    // --- 测试 ---
    public static void main(String[] args) throws Exception {
        EventExecutorGroup group = new DefaultEventExecutorGroup(2);
        AsyncCacheService cacheService = new AsyncCacheService(group.next());

        try {
            // 1. 先设置值
            cacheService.setAsync("name", "Alice")
                    .addListener(f -> {
                        if (f.isSuccess()) {
                            System.out.println("✅ 缓存设置成功");
                            // 2. 再获取值
                            cacheService.getAsync("name")
                                    .addListener(f2 -> {
                                        if (f2.isSuccess()) {
                                            System.out.println("✅ 获取缓存: name = " + f2.get());
                                        }
                                    });
                        }
                    });

            // 等待完成
            Thread.sleep(2000);

        } finally {
            group.shutdownGracefully();
        }
    }
}

1.5.4 trySuccess vs setSuccess 的区别

package cn.tcmeta.promise;

import io.netty.util.concurrent.*;

/**
 * 演示 trySuccess 和 setSuccess 的区别
 */
public class TrySuccessVsSetSuccessExample {

    public static void main(String[] args) throws Exception {
        EventExecutor executor = new DefaultEventExecutor();
        // 创建 Promise
        Promise<Void> promise = new DefaultPromise<>(executor);

        // 添加监听器
        promise.addListener((GenericFutureListener<Promise<Void>>) f -> {
            if (f.isSuccess()) {
                System.out.println("监听器收到成功通知");
            } else {
                System.err.println("监听器收到失败通知: " + f.cause().getMessage());
            }
        });

        // 第一次设置成功
        boolean result1 = promise.trySuccess(null);
        System.out.println("第一次 trySuccess: " + result1); // true

        // 第二次设置（已锁定）
        try {
            promise.setSuccess(null); // ❌ 抛出 IllegalStateException
        } catch (IllegalStateException e) {
            System.err.println("setSuccess 第二次调用异常: " + e.getMessage());
        }

        boolean result2 = promise.trySuccess(null);
        System.out.println("第二次 trySuccess: " + result2); // false

        executor.shutdownGracefully();
    }
}

📌 结论：

• setSuccess()：强制设置，失败则抛异常
• trySuccess()：尝试设置，失败则返回 false，更安全

1.5.5 Promise与异步操作结合

• 模拟异步操作数据库

package cn.tcmeta.promise;

import io.netty.util.concurrent.DefaultEventExecutor;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Promise;

import java.util.concurrent.Callable;

public class PromiseWithAsyncOperation {
    public static void main(String[] args) throws InterruptedException {
        EventExecutor executor = new DefaultEventExecutor();

        // 模拟异步数据库查询
        Promise<String> dbQueryPromise = executeAsyncDatabaseQuery(executor, "SELECT * FROM users");

        // 添加多个监听器处理不同情况
        dbQueryPromise.addListener(future -> {
            if (future.isSuccess()) {
                System.out.println("数据库查询成功: " + future.getNow());
                processQueryResults((String) future.getNow());
            }
        });

        dbQueryPromise.addListener(future -> {
            if (future.isCancelled()) {
                System.out.println("数据库查询被取消");
            }
        });

        dbQueryPromise.addListener(future -> {
            if (!future.isSuccess() && !future.isCancelled()) {
                System.err.println("数据库查询失败: " + future.cause().getMessage());
                handleQueryFailure(future.cause());
            }
        });

        // 等待操作完成
        Thread.sleep(2000);
        executor.shutdownGracefully();
    }

    private static Promise<String> executeAsyncDatabaseQuery(EventExecutor executor, String query) {
        // 创建Promise
        Promise<String> promise = executor.newPromise();

        // 模拟异步执行数据库查询
        executor.submit(() -> {
            try {
                System.out.println("执行数据库查询: " + query);
                Thread.sleep(800); // 模拟查询耗时

                // 模拟随机成功/失败
                if (Math.random() > 0.2) {
                    String result = "用户数据: [User1, User2, User3]";
                    promise.setSuccess(result); // 设置成功结果
                } else {
                    throw new RuntimeException("数据库连接超时");
                }
            } catch (InterruptedException e) {
                promise.setFailure(e);
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                promise.setFailure(e); // 设置失败结果
            }
        });

        return promise;
    }

    private static void processQueryResults(String results) {
        System.out.println("处理查询结果: " + results);
    }

    private static void handleQueryFailure(Throwable cause) {
        System.err.println("处理查询失败: " + cause.getMessage());
        // 记录日志、重试等操作
    }
}

1.6 实践经验与最佳实践

1.6.1 Promise 使用最佳实践

package cn.tcmeta.promise;

import io.netty.util.concurrent.*;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;

public class PromiseBestPractices {
    
    // 1. ✅✅ 正确的Promise创建方式
    public static Promise<String> createPromise(EventExecutor executor) {
        // 始终使用executor.newPromise()而不是new DefaultPromise()
        return executor.newPromise();
    }
    
    // 2. ✅✅ 安全的Promise结果设置
    public static void setPromiseResultSafely(Promise<String> promise, String result) {
        // 使用trySuccess/tryFailure而不是setSuccess/setFailure
        // 这样可以避免抛出IllegalStateException
        if (!promise.trySuccess(result)) {
            System.out.println("Promise已经完成，无法设置结果");
            // 可以在这里处理已经完成的情况
        }
    }
    
    // 3. ✅✅ 带超时控制的Promise
    public static Promise<String> createTimeoutPromise(EventExecutor executor, long timeoutMs) {
        Promise<String> promise = executor.newPromise();
        
        // 设置超时监听器
        executor.schedule(() -> {
            if (!promise.isDone()) {
                System.out.println("操作超时，取消Promise");
                promise.tryFailure(new TimeoutException("超时了~~~"));
            }
        }, timeoutMs, TimeUnit.MILLISECONDS);
        
        return promise;
    }
    
    // 4. ✅✅ Promise组合模式
    public static Promise<String> combinePromises(EventExecutor executor, 
                                                Promise<String> promise1, 
                                                Promise<String> promise2) {
        Promise<String> combinedPromise = executor.newPromise();
        
        // 监听第一个Promise
        promise1.addListener(f1 -> {
            if (f1.isSuccess() && promise2.isSuccess()) {
                String result1 = (String) f1.getNow();
                String result2 = promise2.getNow();
                combinedPromise.setSuccess(result1 + " & " + result2);
            } else if (!f1.isSuccess()) {
                combinedPromise.setFailure(f1.cause());
            }
        });
        
        // 监听第二个Promise
        promise2.addListener(f2 -> {
            if (f2.isSuccess() && promise1.isSuccess()) {
                String result1 = promise1.getNow();
                String result2 = (String) f2.getNow();
                combinedPromise.setSuccess(result1 + " & " + result2);
            } else if (!f2.isSuccess() && !combinedPromise.isDone()) {
                combinedPromise.setFailure(f2.cause());
            }
        });
        
        return combinedPromise;
    }
    
    // 5. ✅✅ 错误处理和重试机制
    public static void executeWithRetry(EventExecutor executor, 
                                      Callable<String> task,
                                      int maxRetries,
                                      Promise<String> resultPromise) {
        AtomicInteger attempt = new AtomicInteger(0);
        
        executor.execute(() -> {
            int currentAttempt = attempt.incrementAndGet();
            try {
                String result = task.call();
                resultPromise.setSuccess(result);
            } catch (Exception e) {
                if (currentAttempt < maxRetries) {
                    System.out.println("尝试 " + currentAttempt + " 失败，准备重试: " + e.getMessage());
                    // 延迟后重试
                    executor.schedule(() -> 
                        executeWithRetry(executor, task, maxRetries, resultPromise),
                        100, TimeUnit.MILLISECONDS);
                } else {
                    resultPromise.setFailure(new RuntimeException("所有重试尝试都失败了", e));
                }
            }
        });
    }
    
    public static void main(String[] args) throws InterruptedException {
        EventExecutor executor = new DefaultEventExecutor();
        
        System.out.println("=== 测试安全结果设置 ===");
        Promise<String> promise1 = createPromise(executor);
        setPromiseResultSafely(promise1, "测试结果");
        setPromiseResultSafely(promise1, "第二次设置应该失败");
        
        System.out.println("=== 测试超时控制 ===");
        Promise<String> timeoutPromise = createTimeoutPromise(executor, 500);
        Thread.sleep(600); // 等待超时
        System.out.println("超时Promise状态: " + timeoutPromise.isDone());
        
        System.out.println("=== 测试重试机制 ===");
        Promise<String> retryPromise = createPromise(executor);
        executeWithRetry(executor, () -> {
            if (Math.random() > 0.7) {
                return "成功结果";
            }
            throw new RuntimeException("模拟失败");
        }, 3, retryPromise);
        
        retryPromise.addListener(f -> {
            if (f.isSuccess()) {
                System.out.println("重试成功: " + f.getNow());
            } else {
                System.err.println("重试失败: " + f.cause().getMessage());
            }
        });
        
        Thread.sleep(2000);
        executor.shutdownGracefully();
    }
}

=== 测试安全结果设置 ===
Promise已经完成，无法设置结果
=== 测试超时控制 ===
操作超时，取消Promise
超时Promise状态: true
=== 测试重试机制 ===
尝试 1 失败，准备重试: 模拟失败
尝试 1 失败，准备重试: 模拟失败
尝试 1 失败，准备重试: 模拟失败
尝试 1 失败，准备重试: 模拟失败
重试成功: 成功结果

1.6.2 Promise高级用法

package cn.tcmeta.promise;

import io.netty.util.concurrent.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class AdvancedPromiseUsage {
    
    // 1. Promise 聚合模式
    public static Promise<List<String>> aggregatePromises(EventExecutor executor, 
                                                        List<Promise<String>> promises) {
        Promise<List<String>> aggregatePromise = executor.newPromise();
        List<String> results = new CopyOnWriteArrayList<>();
        AtomicInteger completedCount = new AtomicInteger(0);
        
        for (Promise<String> promise : promises) {
            promise.addListener(future -> {
                if (future.isSuccess()) {
                    results.add((String) future.getNow());
                }
                
                // 检查是否所有Promise都完成了
                if (completedCount.incrementAndGet() == promises.size()) {
                    if (results.size() == promises.size()) {
                        aggregatePromise.setSuccess(results);
                    } else {
                        aggregatePromise.setFailure(new RuntimeException("部分操作失败"));
                    }
                }
            });
        }
        
        return aggregatePromise;
    }
    
    // 2. Promise 链式操作
    public static Promise<String> createOperationChain(EventExecutor executor, String input) {
        Promise<String> finalPromise = executor.newPromise();
        
        // 第一阶段：处理输入
        Promise<String> stage1 = executor.newPromise();
        executor.execute(() -> {
            try {
                String result1 = "阶段1-" + input.toUpperCase();
                stage1.setSuccess(result1);
            } catch (Exception e) {
                stage1.setFailure(e);
            }
        });
        
        // 第二阶段：基于第一阶段结果继续处理
        stage1.addListener(f1 -> {
            if (f1.isSuccess()) {
                Promise<String> stage2 = executor.newPromise();
                executor.execute(() -> {
                    try {
                        String result2 = "阶段2-" + ((String) f1.getNow()).length();
                        stage2.setSuccess(result2);
                    } catch (Exception e) {
                        stage2.setFailure(e);
                    }
                });
                
                // 第三阶段：完成链式操作
                stage2.addListener(f2 -> {
                    if (f2.isSuccess()) {
                        finalPromise.setSuccess("最终结果-" + f2.getNow());
                    } else {
                        finalPromise.setFailure(f2.cause());
                    }
                });
            } else {
                finalPromise.setFailure(f1.cause());
            }
        });
        
        return finalPromise;
    }
    
    // 3. 可取消的Promise操作
    public static Promise<String> createCancellableOperation(EventExecutor executor, 
                                                           Callable<String> task) {
        Promise<String> promise = executor.newPromise();
        
        // 提交任务
        Future<?> taskFuture = executor.submit(() -> {
            try {
                if (!promise.isCancelled()) {
                    String result = task.call();
                    promise.setSuccess(result);
                }
            } catch (Exception e) {
                if (!promise.isCancelled()) {
                    promise.setFailure(e);
                }
            }
        });
        
        // 设置取消回调
        promise.addListener(f -> {
            if (f.isCancelled()) {
                taskFuture.cancel(true);
                System.out.println("任务已取消");
            }
        });
        
        return promise;
    }
    
    public static void main(String[] args) throws InterruptedException {
        EventExecutor executor = new DefaultEventExecutor();
        
        System.out.println("=== 测试Promise聚合 ===");
        List<Promise<String>> promises = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Promise<String> promise = executor.newPromise();
            promises.add(promise);
            
            // 模拟异步设置结果
            int finalI = i;
            executor.execute(() -> {
                try {
                    Thread.sleep(100 * (finalI + 1));
                    promise.setSuccess("结果-" + finalI);
                } catch (InterruptedException e) {
                    promise.setFailure(e);
                }
            });
        }
        
        Promise<List<String>> aggregate = aggregatePromises(executor, promises);
        aggregate.addListener(f -> {
            if (f.isSuccess()) {
                System.out.println("聚合结果: " + f.getNow());
            }
        });
        
        System.out.println("=== 测试链式操作 ===");
        Promise<String> chain = createOperationChain(executor, "test");
        chain.addListener(f -> System.out.println("链式结果: " + f.getNow()));
        
        System.out.println("=== 测试可取消操作 ===");
        Promise<String> cancellable = createCancellableOperation(executor, () -> {
            Thread.sleep(1000);
            return "长时间运行的结果";
        });
        
        // 添加取消逻辑
        executor.schedule(() -> {
            if (!cancellable.isDone()) {
                cancellable.cancel(true);
            }
        }, 500, TimeUnit.MILLISECONDS);
        
        Thread.sleep(2000);
        executor.shutdownGracefully();
    }
}

1.7 最佳实践与常见陷阱

1.7.1 ✅ 推荐实践

实践	说明
优先使用 trySuccess()	避免 IllegalStateException
在正确的线程中设置结果	通常在 EventLoop 或任务线程中
及时释放资源	在监听器中清理临时对象
处理所有异常	确保 setFailure() 被调用
避免在监听器中阻塞	防止阻塞 EventLoop

1.7.2 ⚠️ 常见错误

// ❌ 错误：在非 EventLoop 线程中创建监听器并阻塞
someFuture.addListener(f -> {
    f.sync(); // ❌ 死锁风险！
});

// ✅ 正确：使用嵌套监听器
someFuture.addListener(f1 -> {
    anotherFuture.addListener(f2 -> {
        // 处理两个结果
    });
});

1.8 Promise优缺点分析

1.8.1 ✅ 优点

优点	说明
真正的异步编程基石	实现非阻塞 I/O 的关键
解耦生产者与消费者	任务执行者与结果处理者分离
线程安全	多线程环境下可靠
支持链式调用	构建复杂异步流程
性能优异	避免线程阻塞，资源利用率高

1.8.2 ❌ 缺点

缺点	说明
学习成本高	需理解异步模型和回调机制
调试困难	堆栈不连续，日志分散
错误处理分散	每个监听器需独立处理异常
过度使用 sync()	易导致死锁或性能问题

1.9 Promise的核心价值

维度	说明
核心角色	异步操作的“可写承诺”
设计模式	生产者-消费者 + 观察者模式
核心能力	设置结果 + 通知监听器
适用场景	所有异步 I/O、自定义异步任务、资源获取
Netty 地位	ChannelFuture、Bootstrap.connect() 等底层都基于 Promise

1.10 ✅ 一句话总结

Netty 的 Promise 是异步编程的“开关”

• 它让你从被动等待结果（Future）转变为主动交付结果（Promise)
• 构建高性能、可扩展网络应用的核心原语。