public abstract class BucketedCounterStream<Event extends HystrixEvent, Bucket, Output> {
    // ...
}

protected final int numBuckets;
protected final Observable<Bucket> bucketedStream;
private final Func1<Observable<Event>, Observable<Bucket>> reduceBucketToSummary;
protected BucketedCounterStream(final HystrixEventStream<Event> inputEventStream, final int numBuckets, final int bucketSizeInMs,
                                final Func2<Bucket, Event, Bucket> appendRawEventToBucket) {
    this.numBuckets = numBuckets;
    this.reduceBucketToSummary = eventBucket -> eventBucket.reduce(getEmptyBucketSummary(), appendRawEventToBucket);
    final List<Bucket> emptyEventCountsToStart = new ArrayList<>();
    for (int i = 0; i < numBuckets; i++) {
        emptyEventCountsToStart.add(getEmptyBucketSummary());
    }
    this.bucketedStream = Observable.defer(() -> {
        return inputEventStream
                .observe()
                .window(bucketSizeInMs, TimeUnit.MILLISECONDS) //bucket it by the counter window so we can emit to the next operator in time chunks, not on every OnNext
                .flatMap(reduceBucketToSummary)                //for a given bucket, turn it into a long array containing counts of event types
                .startWith(emptyEventCountsToStart);           //start it with empty arrays to make consumer logic as generic as possible (windows are always full)
    });
}

public interface HystrixEventStream<E extends HystrixEvent> {
    Observable<E> observe();
}

public class HystrixCommandCompletionStream implements HystrixEventStream<HystrixCommandCompletion> {
    private final HystrixCommandKey commandKey;
    private final Subject<HystrixCommandCompletion, HystrixCommandCompletion> writeOnlySubject;
    private final Observable<HystrixCommandCompletion> readOnlyStream;
    private static final ConcurrentMap<String, HystrixCommandCompletionStream> streams = new ConcurrentHashMap<String, HystrixCommandCompletionStream>();
    public static HystrixCommandCompletionStream getInstance(HystrixCommandKey commandKey) {
        // 此段代码略，大致逻辑为：若对应的 CommandKey 的事件流已创建就从缓存中取出，否则就新创建并缓存起来，保证每个 CommandKey 只有一个实例
    }
    HystrixCommandCompletionStream(final HystrixCommandKey commandKey) {
        this.commandKey = commandKey;
        this.writeOnlySubject = new SerializedSubject<HystrixCommandCompletion, HystrixCommandCompletion>(PublishSubject.<HystrixCommandCompletion>create());
        this.readOnlyStream = writeOnlySubject.share();
    }
    public static void reset() {
        streams.clear();
    }
    public void write(HystrixCommandCompletion event) {
        writeOnlySubject.onNext(event);
    }
    @Override
    public Observable<HystrixCommandCompletion> observe() {
        return readOnlyStream;
    }
}

public class HystrixThreadEventStream {
    private final long threadId;
    private final String threadName;
    private final Subject<HystrixCommandExecutionStarted, HystrixCommandExecutionStarted> writeOnlyCommandStartSubject;
    private final Subject<HystrixCommandCompletion, HystrixCommandCompletion> writeOnlyCommandCompletionSubject;
    private final Subject<HystrixCollapserEvent, HystrixCollapserEvent> writeOnlyCollapserSubject;
    private static final ThreadLocal<HystrixThreadEventStream> threadLocalStreams = new ThreadLocal<HystrixThreadEventStream>() {
        @Override
        protected HystrixThreadEventStream initialValue() {
            return new HystrixThreadEventStream(Thread.currentThread());
        }
    };
    private static final Action1<HystrixCommandCompletion> writeCommandCompletionsToShardedStreams = commandCompletion -> {
        HystrixCommandCompletionStream commandStream = HystrixCommandCompletionStream.getInstance(commandCompletion.getCommandKey());
        commandStream.write(commandCompletion);
        if (commandCompletion.isExecutedInThread() || commandCompletion.isResponseThreadPoolRejected()) {
            HystrixThreadPoolCompletionStream threadPoolStream = HystrixThreadPoolCompletionStream.getInstance(commandCompletion.getThreadPoolKey());
            threadPoolStream.write(commandCompletion);
        }
    };
    /* package */ HystrixThreadEventStream(Thread thread) {
        this.threadId = thread.getId();
        this.threadName = thread.getName();
        writeOnlyCommandCompletionSubject = PublishSubject.create();
        writeOnlyCommandCompletionSubject
                .onBackpressureBuffer()
                .doOnNext(writeCommandCompletionsToShardedStreams)
                .unsafeSubscribe(Subscribers.empty());
    }
    public static HystrixThreadEventStream getInstance() {
        return threadLocalStreams.get();
    }
    public void shutdown() {
        writeOnlyCommandStartSubject.onCompleted();
        writeOnlyCommandCompletionSubject.onCompleted();
        writeOnlyCollapserSubject.onCompleted();
    }
    // 执行完毕/异常/超时都会调用此方法
    public void executionDone(ExecutionResult executionResult, HystrixCommandKey commandKey, HystrixThreadPoolKey threadPoolKey) {
        HystrixCommandCompletion event = HystrixCommandCompletion.from(executionResult, commandKey, threadPoolKey);
        writeOnlyCommandCompletionSubject.onNext(event);
    }
}

private void handleCommandEnd(boolean commandExecutionStarted) {
    Reference<TimerListener> tl = timeoutTimer.get();
    if (tl != null) {
        tl.clear();
    }
    long userThreadLatency = System.currentTimeMillis() - commandStartTimestamp;
    executionResult = executionResult.markUserThreadCompletion((int) userThreadLatency);
    if (executionResultAtTimeOfCancellation == null) {
        metrics.markCommandDone(executionResult, commandKey, threadPoolKey, commandExecutionStarted);
    } else {
        metrics.markCommandDone(executionResultAtTimeOfCancellation, commandKey, threadPoolKey, commandExecutionStarted);
    }
    if (endCurrentThreadExecutingCommand != null) {
        endCurrentThreadExecutingCommand.call();
    }
}

@Override
public Observable<HystrixCommandCompletion> observe() {
    return readOnlyStream;
}

this.readOnlyStream = writeOnlySubject.share();

public final Observable<T> share() {
    return publish().refCount();
}

this.bucketedStream = Observable.defer(() -> { // defer 的意思是 lazy 创建
    return inputEventStream
            .observe()
            .window(bucketSizeInMs, TimeUnit.MILLISECONDS) // 按单元窗口长度来将某个时间段内的调用事件聚集起来
            .flatMap(reduceBucketToSummary)                // 将每个单元窗口内聚集起来的事件集合聚合成桶
            .startWith(emptyEventCountsToStart);           // 为了保证窗口的完整性，开始的时候先产生一串空的桶
});

this.reduceBucketToSummary = eventBucket -> eventBucket.reduce(getEmptyBucketSummary(), appendRawEventToBucket);

public abstract class BucketedRollingCounterStream<Event extends HystrixEvent, Bucket, Output> extends BucketedCounterStream<Event, Bucket, Output> {
    private Observable<Output> sourceStream;
    private final AtomicBoolean isSourceCurrentlySubscribed = new AtomicBoolean(false);
    protected BucketedRollingCounterStream(HystrixEventStream<Event> stream, final int numBuckets, int bucketSizeInMs,
                                           final Func2<Bucket, Event, Bucket> appendRawEventToBucket,
                                           final Func2<Output, Bucket, Output> reduceBucket) {
        super(stream, numBuckets, bucketSizeInMs, appendRawEventToBucket);
        Func1<Observable<Bucket>, Observable<Output>> reduceWindowToSummary = window -> window.scan(getEmptyOutputValue(), reduceBucket).skip(numBuckets);
        this.sourceStream = bucketedStream      // 数据流，每个对象代表单元窗口产生的桶
                .window(numBuckets, 1)          // 按照滑动窗口桶的个数进行桶的聚集
                .flatMap(reduceWindowToSummary) // 将一系列的桶聚集成最后的数据对象
                .doOnSubscribe(() -> isSourceCurrentlySubscribed.set(true))
                .doOnUnsubscribe(() -> isSourceCurrentlySubscribed.set(false))
                .share()                        // 不同的订阅者看到的数据是一致的
                .onBackpressureDrop();          // 流量控制，当消费者消费速度过慢时就丢弃数据，不进行积压
    }
    @Override
    public Observable<Output> observe() {
        return sourceStream;
    }
    /* package-private */ boolean isSourceCurrentlySubscribed() {
        return isSourceCurrentlySubscribed.get();
    }
}

Func1<Observable<Bucket>, Observable<Output>> reduceWindowToSummary = window -> window.scan(getEmptyOutputValue(), reduceBucket).skip(numBuckets);

public static final Func2<long[], HystrixCommandCompletion, long[]> appendEventToBucket = (initialCountArray, execution) -> {
    ExecutionResult.EventCounts eventCounts = execution.getEventCounts();
    for (HystrixEventType eventType: ALL_EVENT_TYPES) {
        switch (eventType) {
            case EXCEPTION_THROWN: break; //this is just a sum of other anyway - don't do the work here
            default:
                initialCountArray[eventType.ordinal()] += eventCounts.getCount(eventType);
                break;
        }
    }
    return initialCountArray;
};

private static final Func2<HystrixCommandMetrics.HealthCounts, long[], HystrixCommandMetrics.HealthCounts> healthCheckAccumulator = HystrixCommandMetrics.HealthCounts::plus;
// 具体的实现，位于 HystrixCommandMetrics.HealthCounts 类内
public HealthCounts plus(long[] eventTypeCounts) {
    long updatedTotalCount = totalCount; // 之前的请求总数
    long updatedErrorCount = errorCount; // 之前的失败个数
    long successCount = eventTypeCounts[HystrixEventType.SUCCESS.ordinal()];
    long failureCount = eventTypeCounts[HystrixEventType.FAILURE.ordinal()];
    long timeoutCount = eventTypeCounts[HystrixEventType.TIMEOUT.ordinal()];
    long threadPoolRejectedCount = eventTypeCounts[HystrixEventType.THREAD_POOL_REJECTED.ordinal()];
    long semaphoreRejectedCount = eventTypeCounts[HystrixEventType.SEMAPHORE_REJECTED.ordinal()];
    // 加上所有事件的总数
    updatedTotalCount += (successCount + failureCount + timeoutCount + threadPoolRejectedCount + semaphoreRejectedCount);
    // 加上失败事件的总数（包括请求失败、超时、线程池满、信号量满）
    updatedErrorCount += (failureCount + timeoutCount + threadPoolRejectedCount + semaphoreRejectedCount);
    return new HealthCounts(updatedTotalCount, updatedErrorCount);
}

/* package */class HystrixCircuitBreakerImpl implements HystrixCircuitBreaker {
    private final HystrixCommandProperties properties;
    private final HystrixCommandMetrics metrics;
    enum Status {
        CLOSED, OPEN, HALF_OPEN;
    }
    private final AtomicReference<Status> status = new AtomicReference<Status>(Status.CLOSED);
    private final AtomicLong circuitOpened = new AtomicLong(-1);
    private final AtomicReference<Subscription> activeSubscription = new AtomicReference<Subscription>(null);
    protected HystrixCircuitBreakerImpl(HystrixCommandKey key, HystrixCommandGroupKey commandGroup, final HystrixCommandProperties properties, HystrixCommandMetrics metrics) {
        this.properties = properties;
        this.metrics = metrics;
        //On a timer, this will set the circuit between OPEN/CLOSED as command executions occur
        Subscription s = subscribeToStream();
        activeSubscription.set(s);
    }
    private Subscription subscribeToStream() {
        /*
         * This stream will recalculate the OPEN/CLOSED status on every onNext from the health stream
         */
        return metrics.getHealthCountsStream()
                .observe()
                .subscribe(new Subscriber<HealthCounts>() {
                    @Override
                    public void onCompleted() {
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(HealthCounts hc) {
                        // check if we are past the statisticalWindowVolumeThreshold
                        if (hc.getTotalRequests() < properties.circuitBreakerRequestVolumeThreshold().get()) {
                            // we are not past the minimum volume threshold for the stat window,
                            // so no change to circuit status.
                            // if it was CLOSED, it stays CLOSED
                            // if it was half-open, we need to wait for a successful command execution
                            // if it was open, we need to wait for sleep window to elapse
                        } else {
                            if (hc.getErrorPercentage() < properties.circuitBreakerErrorThresholdPercentage().get()) {
                                //we are not past the minimum error threshold for the stat window,
                                // so no change to circuit status.
                                // if it was CLOSED, it stays CLOSED
                                // if it was half-open, we need to wait for a successful command execution
                                // if it was open, we need to wait for sleep window to elapse
                            } else {
                                // our failure rate is too high, we need to set the state to OPEN
                                if (status.compareAndSet(Status.CLOSED, Status.OPEN)) {
                                    circuitOpened.set(System.currentTimeMillis());
                                }
                            }
                        }
                    }
                });
    }
}

@Override
public Thread newThread(Runnable runnable) {
  VertxThread t = new VertxThread(runnable, prefix + threadCount.getAndIncrement(), worker, maxExecTime);
  if (checker != null) {
    checker.registerThread(t);
  }
  addToMap(t);
  t.setDaemon(false);
  return t;
}

protected ContextImpl(VertxInternal vertx, WorkerPool internalBlockingPool, WorkerPool workerPool, String deploymentID, JsonObject config,
                        ClassLoader tccl) {
    // ...
    EventLoopGroup group = vertx.getEventLoopGroup();
    if (group != null) {
      this.eventLoop = group.next();
    } else {
      this.eventLoop = null;
    }
    // ...
  }

eventLoopGroup = new NioEventLoopGroup(options.getEventLoopPoolSize(), eventLoopThreadFactory);
eventLoopGroup.setIoRatio(NETTY_IO_RATIO);

@Override
public EventExecutorChooser newChooser(EventExecutor[] executors) {
    if (isPowerOfTwo(executors.length)) {
        return new PowerOfTowEventExecutorChooser(executors);
    } else {
        return new GenericEventExecutorChooser(executors);
    }
}

private static final class GenericEventExecutorChooser implements EventExecutorChooser {
    // ...
    @Override
    public EventExecutor next() {
        return executors[Math.abs(idx.getAndIncrement() % executors.length)];
    }
}
private static final class PowerOfTowEventExecutorChooser implements EventExecutorChooser {
    // ...
    @Override
    public EventExecutor next() {
        return executors[idx.getAndIncrement() & executors.length - 1];
    }
}

System.out.println(Thread.currentThread());
Vertx vertx = Vertx.vertx();
for (int i = 0; i < 20; i++) {
  int index = i;
  vertx.setTimer(1, t -> {
    System.out.println(index + ":" + Thread.currentThread());
  });

Thread[main,5,main]
0:Thread[vert.x-eventloop-thread-0,5,main]
1:Thread[vert.x-eventloop-thread-1,5,main]
2:Thread[vert.x-eventloop-thread-2,5,main]
3:Thread[vert.x-eventloop-thread-3,5,main]
5:Thread[vert.x-eventloop-thread-5,5,main]
6:Thread[vert.x-eventloop-thread-6,5,main]
8:Thread[vert.x-eventloop-thread-8,5,main]
7:Thread[vert.x-eventloop-thread-7,5,main]
10:Thread[vert.x-eventloop-thread-10,5,main]
9:Thread[vert.x-eventloop-thread-9,5,main]
4:Thread[vert.x-eventloop-thread-4,5,main]
11:Thread[vert.x-eventloop-thread-11,5,main]
12:Thread[vert.x-eventloop-thread-12,5,main]
13:Thread[vert.x-eventloop-thread-13,5,main]
14:Thread[vert.x-eventloop-thread-14,5,main]
16:Thread[vert.x-eventloop-thread-0,5,main]
17:Thread[vert.x-eventloop-thread-1,5,main]
15:Thread[vert.x-eventloop-thread-15,5,main]
18:Thread[vert.x-eventloop-thread-2,5,main]
19:Thread[vert.x-eventloop-thread-3,5,main]

public void executeAsync(Handler<Void> task) {
  // No metrics, we are on the event loop.
  nettyEventLoop().execute(wrapTask(null, task, true, null));
}

@Override
protected void run() {
    for (;;) {
        try {
            switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                case SelectStrategy.CONTINUE:
                    continue;
                case SelectStrategy.SELECT:
                    select(wakenUp.getAndSet(false));
                    if (wakenUp.get()) {
                        selector.wakeup();
                    }
                default:
                    // fallthrough
            }
            cancelledKeys = 0;
            needsToSelectAgain = false;
            final int ioRatio = this.ioRatio;
            if (ioRatio == 100) {
                processSelectedKeys();
                runAllTasks();
            } else {
                final long ioStartTime = System.nanoTime();
                processSelectedKeys();
                final long ioTime = System.nanoTime() - ioStartTime;
                runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
            }
            if (isShuttingDown()) {
                closeAll();
                if (confirmShutdown()) {
                    break;
                }
            }
        } catch (Throwable t) {
            // process the error
            // ...
        }
    }
}

for (Verticle verticle: verticles) {
  WorkerExecutorImpl workerExec = poolName != null ? vertx.createSharedWorkerExecutor(poolName, options.getWorkerPoolSize()) : null;
  WorkerPool pool = workerExec != null ? workerExec.getPool() : null;
  // 根据配置创建Context
  ContextImpl context = options.isWorker() ? vertx.createWorkerContext(options.isMultiThreaded(), deploymentID, pool, conf, tccl) :
    vertx.createEventLoopContext(deploymentID, pool, conf, tccl);
  if (workerExec != null) {
    context.addCloseHook(workerExec);
  }
  context.setDeployment(deployment);
  deployment.addVerticle(new VerticleHolder(verticle, context));
  // 此Verticle上的Handler都会在创建的context作用域内执行
  context.runOnContext(v -> {
    try {
      verticle.init(vertx, context);
      Future<Void> startFuture = Future.future();
      // 大家熟悉的start方法的执行点
      verticle.start(startFuture);
      startFuture.setHandler(ar -> {
        if (ar.succeeded()) {
          if (parent != null) {
            parent.addChild(deployment);
            deployment.child = true;
          }
          vertx.metricsSPI().verticleDeployed(verticle);
          deployments.put(deploymentID, deployment);
          if (deployCount.incrementAndGet() == verticles.length) {
            reportSuccess(deploymentID, callingContext, completionHandler);
          }
        } else if (!failureReported.get()) {
          reportFailure(ar.cause(), callingContext, completionHandler);
        }
      });
    } catch (Throwable t) {
      reportFailure(t, callingContext, completionHandler);
    }
  });
}

public class TcpClientVerticle extends AbstractVerticle {
  int i = 0;
  @Override
  public void start() throws Exception {
    vertx.createNetClient().connect(6666, "localhost", ar -> {
      if (ar.succeeded()) {
        NetSocket socket = ar.result();
        System.out.println(Thread.currentThread().getName());
        socket.handler(buffer -> {
          i++;
          System.out.println(Thread.currentThread().getName());
          System.out.println("Net client receiving: " + buffer.toString("UTF-8"));
        });
        socket.write("+1s\n");
      } else {
        ar.cause().printStackTrace();
      }
    });
  }
}

eventLoopThreadFactory = new VertxThreadFactory("vert.x-eventloop-thread-", checker, false, options.getMaxEventLoopExecuteTime());
eventLoopGroup = new NioEventLoopGroup(options.getEventLoopPoolSize(), eventLoopThreadFactory);
eventLoopGroup.setIoRatio(NETTY_IO_RATIO);

ExecutorService workerExec = Executors.newFixedThreadPool(options.getWorkerPoolSize(),
    new VertxThreadFactory("vert.x-worker-thread-", checker, true, options.getMaxWorkerExecuteTime()));
PoolMetrics workerPoolMetrics = isMetricsEnabled() ? metrics.createMetrics(workerExec, "worker", "vert.x-worker-thread", options.getWorkerPoolSize()) : null;
workerPool = new WorkerPool(workerExec, workerPoolMetrics);

ExecutorService internalBlockingExec = Executors.newFixedThreadPool(options.getInternalBlockingPoolSize(),
    new VertxThreadFactory("vert.x-internal-blocking-", checker, true, options.getMaxWorkerExecuteTime()));
PoolMetrics internalBlockingPoolMetrics = isMetricsEnabled() ? metrics.createMetrics(internalBlockingExec, "worker", "vert.x-internal-blocking", options.getInternalBlockingPoolSize()) : null;
internalBlockingPool = new WorkerPool(internalBlockingExec, internalBlockingPoolMetrics);

acceptorEventLoopGroup = new NioEventLoopGroup(1, acceptorEventLoopThreadFactory);
acceptorEventLoopGroup.setIoRatio(100);

vertx.setPeriodic(1000, t -> {
  vertx.executeBlocking(future -> {
    try {
      Thread.sleep(200);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName());
    future.complete();
  }, r -> {});
});
vertx.setPeriodic(1000, t -> {
  vertx.executeBlocking(future -> {
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName());
    future.complete();
  }, r -> {});
});

ExecutorService workerExec = Executors.newFixedThreadPool(options.getWorkerPoolSize(),
    new VertxThreadFactory("vert.x-worker-thread-", checker, true, options.getMaxWorkerExecuteTime()));
PoolMetrics workerPoolMetrics = isMetricsEnabled() ? metrics.createMetrics(workerExec, "worker", "vert.x-worker-thread", options.getWorkerPoolSize()) : null;
workerPool = new WorkerPool(workerExec, workerPoolMetrics);

@Override
public <T> void executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered,
                                Handler<AsyncResult<T>> asyncResultHandler) {
  ContextImpl context = getOrCreateContext();
  context.executeBlocking(blockingCodeHandler, ordered, asyncResultHandler);
}
@Override
public <T> void executeBlocking(Handler<Future<T>> blockingCodeHandler,
                                Handler<AsyncResult<T>> asyncResultHandler) {
  executeBlocking(blockingCodeHandler, true, asyncResultHandler);
}

@Override
public <T> void executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler) {
  executeBlocking(null, blockingCodeHandler, resultHandler, ordered ? workerExec : workerPool.executor(), workerPool.metrics());
}
<T> void executeBlocking(Action<T> action, Handler<Future<T>> blockingCodeHandler,
    Handler<AsyncResult<T>> resultHandler,
    Executor exec, PoolMetrics metrics) {
  Object queueMetric = metrics != null ? metrics.submitted() : null;
  try {
    exec.execute(() -> {
      Object execMetric = null;
      if (metrics != null) {
        execMetric = metrics.begin(queueMetric);
      }
      Future<T> res = Future.future();
      try {
        if (blockingCodeHandler != null) {
          ContextImpl.setContext(this);
          blockingCodeHandler.handle(res);
        } else {
          T result = action.perform();
          res.complete(result);
        }
      } catch (Throwable e) {
        res.fail(e);
      }
      if (metrics != null) {
        metrics.end(execMetric, res.succeeded());
      }
      if (resultHandler != null) {
        runOnContext(v -> res.setHandler(resultHandler));
      }
    });
  } catch (RejectedExecutionException ignore) {
    // Pool is already shut down
    if (metrics != null) {
      metrics.rejected(queueMetric);
    }
  }
}

protected final WorkerPool workerPool;
protected final Executor workerExec;

this.workerPool = workerPool;
this.workerExec = workerPool.createOrderedExecutor();

ExecutorService executor() {
  return pool;
}

workerPool = new WorkerPool(workerExec, workerPoolMetrics);

private final OrderedExecutorFactory orderedFact;
private final ExecutorService pool;
private final PoolMetrics metrics;
public WorkerPool(ExecutorService pool, PoolMetrics metrics) {
  this.orderedFact = new OrderedExecutorFactory(pool);
  this.pool = pool;
  this.metrics = metrics;
}
Executor createOrderedExecutor() {
  return orderedFact.getExecutor();
}

public void execute(Runnable command) {
  synchronized (tasks) {
    tasks.add(command);
    if (!running) {
      running = true;
      parent.execute(runner);
    }
  }
}

@ProxyGen
@VertxGen
public interface SomeService {
  String SERVICE_ADDRESS = "service.example";
  static SomeService createService(Vertx vertx, JsonObject config) {
    return new SomeServiceImpl(vertx, config);
  }
  static SomeService createProxy(Vertx vertx) {
    return ProxyHelper.createProxy(SomeService.class, vertx, SERVICE_ADDRESS);
  }
  @Fluent
  SomeService process(String id, Handler<AsyncResult<JsonObject>> resultHandler);
}

SomeService service = SomeService.createService(vertx, config);
ProxyHelper.registerService(SomeService.class, vertx, service, SomeService.SERVICE_ADDRESS);

SomeService proxyService = SomeService.createProxy(vertx);
// invoke the service
proxyService.process("fuck", ar -> {
  // process the result...
});

public static <T> MessageConsumer<JsonObject> registerService(Class<T> clazz, Vertx vertx, T service, String address,
                                                              boolean topLevel,
                                                              long timeoutSeconds) {
  String handlerClassName = clazz.getName() + "VertxProxyHandler";
  Class<?> handlerClass = loadClass(handlerClassName, clazz);
  Constructor constructor = getConstructor(handlerClass, Vertx.class, clazz, boolean.class, long.class);
  Object instance = createInstance(constructor, vertx, service, topLevel, timeoutSeconds);
  ProxyHandler handler = (ProxyHandler) instance;
  return handler.registerHandler(address);
}

public MessageConsumer<JsonObject> registerHandler(String address) {
  MessageConsumer<JsonObject> consumer = vertx.eventBus().<JsonObject>consumer(address).handler(this);
  this.setConsumer(consumer);
  return consumer;
}

public SomeService process(String id, Handler<AsyncResult<JsonObject>> resultHandler) {
  if (closed) {
    resultHandler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
    return this;
  }
  JsonObject _json = new JsonObject();
  _json.put("id", id);
  DeliveryOptions _deliveryOptions = (_options != null) ? new DeliveryOptions(_options) : new DeliveryOptions();
  _deliveryOptions.addHeader("action", "process");
  _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
    if (res.failed()) {
      resultHandler.handle(Future.failedFuture(res.cause()));
    } else {
      resultHandler.handle(Future.succeededFuture(res.result().body()));
    }
  });
  return this;
}

public void handle(Message<JsonObject> msg) {
  try {
    JsonObject json = msg.body();
    String action = msg.headers().get("action");
    if (action == null) {
      throw new IllegalStateException("action not specified");
    }
    accessed();
    switch (action) {
      case "process": {
        service.process((java.lang.String)json.getValue("id"), createHandler(msg));
        break;
      }
      default: {
        throw new IllegalStateException("Invalid action: " + action);
      }
    }
  } catch (Throwable t) {
    msg.reply(new ServiceException(500, t.getMessage()));
    throw t;
  }
}

private <T> Handler<AsyncResult<T>> createHandler(Message msg) {
  return res -> {
    if (res.failed()) {
      if (res.cause() instanceof ServiceException) {
        msg.reply(res.cause());
      } else {
        msg.reply(new ServiceException(-1, res.cause().getMessage()));
      }
    } else {
      if (res.result() != null  && res.result().getClass().isEnum()) {
        msg.reply(((Enum) res.result()).name());
      } else {
        msg.reply(res.result());
      }
    }
  };
}

public SomeServiceVertxProxyHandler(Vertx vertx, SomeService service, boolean topLevel, long timeoutSeconds) {
  // 前面代码略。。。
  if (timeoutSeconds != -1 && !topLevel) {
    long period = timeoutSeconds * 1000 / 2;
    if (period > 10000) {
      period = 10000;
    }
    this.timerID = vertx.setPeriodic(period, this::checkTimedOut);
  } else {
    this.timerID = -1;
  }
  accessed();
}
private void checkTimedOut(long id) {
  long now = System.nanoTime();
  if (now - lastAccessed > timeoutSeconds * 1000000000) {
    close();
  }
}

if (seen(xid)) {
  result = oldResult;
} else {
  result = call(...);
  oldResult = result;
  setCurrentId(xid);
}

@Override
protected <T> void addRegistration(boolean newAddress, String address,
                                   boolean replyHandler, boolean localOnly,
                                   Handler<AsyncResult<Void>> completionHandler) {
  if (newAddress && subs != null && !replyHandler && !localOnly) {
    // Propagate the information
    subs.add(address, serverID, completionHandler);
  } else {
    completionHandler.handle(Future.succeededFuture());
  }
}

private AsyncMultiMap<String, ServerID> subs;

clusterManager.<String, ServerID>getAsyncMultiMap(SUBS_MAP_NAME, ar2 -> {
  if (ar2.succeeded()) {
    subs = ar2.result();
    // 其他代码暂略。。。
  } else {
    // 代码略。。。
  }
});

@Override
protected <T> void removeRegistration(HandlerHolder lastHolder, String address,
                                      Handler<AsyncResult<Void>> completionHandler) {
  if (lastHolder != null && subs != null && !lastHolder.isLocalOnly()) {
    removeSub(address, serverID, completionHandler);
  } else {
    callCompletionHandlerAsync(completionHandler);
  }
}
private void removeSub(String subName, ServerID theServerID, Handler<AsyncResult<Void>> completionHandler) {
  subs.remove(subName, theServerID, ar -> {
    if (!ar.succeeded()) {
      log.error("Failed to remove sub", ar.cause());
    } else {
      if (ar.result()) {
        if (completionHandler != null) {
          completionHandler.handle(Future.succeededFuture());
        }
      } else {
        if (completionHandler != null) {
          completionHandler.handle(Future.failedFuture("sub not found"));
        }
      }
    }
  });
}

@Override
protected MessageImpl createMessage(boolean send, String address, MultiMap headers, Object body, String codecName) {
  Objects.requireNonNull(address, "no null address accepted");
  MessageCodec codec = codecManager.lookupCodec(body, codecName);
  @SuppressWarnings("unchecked")
  ClusteredMessage msg = new ClusteredMessage(serverID, address, null, headers, body, codec, send, this);
  return msg;
}

@Override
public void next() {
  if (iter.hasNext()) {
    Handler<SendContext> handler = iter.next();
    try {
      handler.handle(this);
    } catch (Throwable t) {
      log.error("Failure in interceptor", t);
    }
  } else {
    sendOrPub(this);
  }
}

@Override
protected <T> void sendOrPub(SendContextImpl<T> sendContext) {
  String address = sendContext.message.address();
  Handler<AsyncResult<ChoosableIterable<ServerID>>> resultHandler = asyncResult -> {
    if (asyncResult.succeeded()) {
      ChoosableIterable<ServerID> serverIDs = asyncResult.result();
      if (serverIDs != null && !serverIDs.isEmpty()) {
        sendToSubs(serverIDs, sendContext);
      } else {
        metrics.messageSent(address, !sendContext.message.send(), true, false);
        deliverMessageLocally(sendContext);
      }
    } else {
      log.error("Failed to send message", asyncResult.cause());
    }
  };
  if (Vertx.currentContext() == null) {
    // Guarantees the order when there is no current context
    sendNoContext.runOnContext(v -> {
      subs.get(address, resultHandler);
    });
  } else {
    subs.get(address, resultHandler);
  }
}

private <T> void sendToSubs(ChoosableIterable<ServerID> subs, SendContextImpl<T> sendContext) {
  String address = sendContext.message.address();
  if (sendContext.message.send()) {
    // Choose one
    ServerID sid = subs.choose();
    if (!sid.equals(serverID)) {  //We don't send to this node
      metrics.messageSent(address, false, false, true);
      sendRemote(sid, sendContext.message);
    } else {
      metrics.messageSent(address, false, true, false);
      deliverMessageLocally(sendContext);
    }
  } else {
    // Publish
    boolean local = false;
    boolean remote = false;
    for (ServerID sid : subs) {
      if (!sid.equals(serverID)) {  //We don't send to this node
        remote = true;
        sendRemote(sid, sendContext.message);
      } else {
        local = true;
      }
    }
    metrics.messageSent(address, true, local, remote);
    if (local) {
      deliverMessageLocally(sendContext);
    }
  }
}

private void sendRemote(ServerID theServerID, MessageImpl message) {
  ConnectionHolder holder = connections.get(theServerID);
  if (holder == null) {
    holder = new ConnectionHolder(this, theServerID, options);
    ConnectionHolder prevHolder = connections.putIfAbsent(theServerID, holder);
    if (prevHolder != null) {
      // Another one sneaked in
      holder = prevHolder;
    } else {
      holder.connect();
    }
  }
  holder.writeMessage((ClusteredMessage)message);
}

ConnectionHolder(ClusteredEventBus eventBus, ServerID serverID, EventBusOptions options) {
  this.eventBus = eventBus;
  this.serverID = serverID;
  this.vertx = eventBus.vertx();
  this.metrics = eventBus.getMetrics();
  NetClientOptions clientOptions = new NetClientOptions(options.toJson());
  ClusteredEventBus.setCertOptions(clientOptions, options.getKeyCertOptions());
  ClusteredEventBus.setTrustOptions(clientOptions, options.getTrustOptions());
  client = new NetClientImpl(eventBus.vertx(), clientOptions, false);
}

synchronized void connect() {
  if (connected) {
    throw new IllegalStateException("Already connected");
  }
  client.connect(serverID.port, serverID.host, res -> {
    if (res.succeeded()) {
      connected(res.result());
    } else {
      close();
    }
  });
}

private synchronized void connected(NetSocket socket) {
  this.socket = socket;
  connected = true;
  socket.exceptionHandler(t -> close());
  socket.closeHandler(v -> close());
  socket.handler(data -> {
    // Got a pong back
    vertx.cancelTimer(timeoutID);
    schedulePing();
  });
  // Start a pinger
  schedulePing();
  for (ClusteredMessage message : pending) {
    Buffer data = message.encodeToWire();
    metrics.messageWritten(message.address(), data.length());
    socket.write(data);
  }
  pending.clear();
}

synchronized void writeMessage(ClusteredMessage message) {
  if (connected) {
    Buffer data = message.encodeToWire();
    metrics.messageWritten(message.address(), data.length());
    socket.write(data);
  } else {
    if (pending == null) {
      pending = new ArrayDeque<>();
    }
    pending.add(message);
  }
}

server.connectHandler(getServerHandler());

private Handler<NetSocket> getServerHandler() {
  return socket -> {
    RecordParser parser = RecordParser.newFixed(4, null);
    Handler<Buffer> handler = new Handler<Buffer>() {
      int size = -1;
      public void handle(Buffer buff) {
        if (size == -1) {
          size = buff.getInt(0);
          parser.fixedSizeMode(size);
        } else {
          ClusteredMessage received = new ClusteredMessage();
          received.readFromWire(buff, codecManager);
          metrics.messageRead(received.address(), buff.length());
          parser.fixedSizeMode(4);
          size = -1;
          if (received.codec() == CodecManager.PING_MESSAGE_CODEC) {
            // Just send back pong directly on connection
            socket.write(PONG);
          } else {
            deliverMessageLocally(received);
          }
        }
      }
    };
    parser.setOutput(handler);
    socket.handler(parser);
  };
}

Vertx vertx = Vertx.vertx();
EventBus eventBus = vertx.eventBus();

public EventBus eventBus() {
  if (eventBus == null) {
    // If reading from different thread possibility that it's been set but not visible - so provide
    // memory barrier
    synchronized (this) {
      return eventBus;
    }
  }
  return eventBus;
}

if (options.isClustered()) {
  // 集群模式相关逻辑
} else {
  this.clusterManager = null;
  createAndStartEventBus(options, resultHandler);
}

private void createAndStartEventBus(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler) {
  if (options.isClustered()) {
    eventBus = new ClusteredEventBus(this, options, clusterManager, haManager);
  } else {
    eventBus = new EventBusImpl(this);
  }
  eventBus.start(ar2 -> {
    if (ar2.succeeded()) {
      // If the metric provider wants to use the event bus, it cannot use it in its constructor as the event bus
      // may not be initialized yet. We invokes the eventBusInitialized so it can starts using the event bus.
      metrics.eventBusInitialized(eventBus);
      if (resultHandler != null) {
        resultHandler.handle(Future.succeededFuture(this));
      }
    } else {
      log.error("Failed to start event bus", ar2.cause());
    }
  });
}

public synchronized void start(Handler<AsyncResult<Void>> completionHandler) {
  if (started) {
    throw new IllegalStateException("Already started");
  }
  started = true;
  completionHandler.handle(Future.succeededFuture());
}

<T> MessageConsumer<T> consumer(String address);
<T> MessageConsumer<T> consumer(String address, Handler<Message<T>> handler);

@Override
public <T> MessageConsumer<T> consumer(String address, Handler<Message<T>> handler) {
  Objects.requireNonNull(handler, "handler");
  MessageConsumer<T> consumer = consumer(address);
  consumer.handler(handler);
  return consumer;
}

@Override
public <T> MessageConsumer<T> consumer(String address) {
  checkStarted();
  Objects.requireNonNull(address, "address");
  return new HandlerRegistration<>(vertx, metrics, this, address, null, false, null, -1);
}

@Override
public synchronized MessageConsumer<T> handler(Handler<Message<T>> handler) {
  this.handler = handler;
  if (this.handler != null && !registered) {
    registered = true;
    eventBus.addRegistration(address, this, repliedAddress != null, localOnly);
  } else if (this.handler == null && registered) {
    // This will set registered to false
    this.unregister();
  }
  return this;
}

protected <T> void addRegistration(String address, HandlerRegistration<T> registration,
                                   boolean replyHandler, boolean localOnly) {
  Objects.requireNonNull(registration.getHandler(), "handler");
  boolean newAddress = addLocalRegistration(address, registration, replyHandler, localOnly);
  addRegistration(newAddress, address, replyHandler, localOnly, registration::setResult);
}

protected <T> boolean addLocalRegistration(String address, HandlerRegistration<T> registration,
                                           boolean replyHandler, boolean localOnly) {
  Objects.requireNonNull(address, "address");
  Context context = Vertx.currentContext();
  boolean hasContext = context != null;
  if (!hasContext) {
    // Embedded
    context = vertx.getOrCreateContext();
  }
  registration.setHandlerContext(context);
  boolean newAddress = false;
  HandlerHolder holder = new HandlerHolder<>(metrics, registration, replyHandler, localOnly, context);
  Handlers handlers = handlerMap.get(address);
  if (handlers == null) {
    handlers = new Handlers();
    Handlers prevHandlers = handlerMap.putIfAbsent(address, handlers);
    if (prevHandlers != null) {
      handlers = prevHandlers;
    }
    newAddress = true;
  }
  handlers.list.add(holder);
  if (hasContext) {
    HandlerEntry entry = new HandlerEntry<>(address, registration);
    context.addCloseHook(entry);
  }
  return newAddress;
}

public class Handlers {
  private final AtomicInteger pos = new AtomicInteger(0);
  public final List<HandlerHolder> list = new CopyOnWriteArrayList<>();
  public HandlerHolder choose() {
    while (true) {
      int size = list.size();
      if (size == 0) {
        return null;
      }
      int p = pos.getAndIncrement();
      if (p >= size - 1) {
        pos.set(0);
      }
      try {
        return list.get(p);
      } catch (IndexOutOfBoundsException e) {
        // Can happen
        pos.set(0);
      }
    }
  }
}

public class HandlerEntry<T> implements Closeable {
  final String address;
  final HandlerRegistration<T> handler;
  public HandlerEntry(String address, HandlerRegistration<T> handler) {
    this.address = address;
    this.handler = handler;
  }
  // ...
  // Called by context on undeploy
  public void close(Handler<AsyncResult<Void>> completionHandler) {
    handler.unregister(completionHandler);
    completionHandler.handle(Future.succeededFuture());
  }
}

public synchronized void doUndeploy(ContextImpl undeployingContext, Handler<AsyncResult<Void>> completionHandler) {
  // 前面代码略
  context.runCloseHooks(ar2 -> {
    if (ar2.failed()) {
      // Log error but we report success anyway
      log.error("Failed to run close hook", ar2.cause());
    }
    if (ar.succeeded() && undeployCount.incrementAndGet() == numToUndeploy) {
      reportSuccess(null, undeployingContext, completionHandler);
    } else if (ar.failed() && !failureReported.get()) {
      failureReported.set(true);
      reportFailure(ar.cause(), undeployingContext, completionHandler);
    }
  });
  // 后面代码略
}

protected <T> void addRegistration(boolean newAddress, String address,
                                   boolean replyHandler, boolean localOnly,
                                   Handler<AsyncResult<Void>> completionHandler) {
  completionHandler.handle(Future.succeededFuture());
}

public synchronized void setResult(AsyncResult<Void> result) {
  this.result = result;
  if (completionHandler != null) {
    if (result.succeeded()) {
      metric = metrics.handlerRegistered(address, repliedAddress);
    }
    Handler<AsyncResult<Void>> callback = completionHandler;
    vertx.runOnContext(v -> callback.handle(result));
  } else if (result.failed()) {
    log.error("Failed to propagate registration for handler " + handler + " and address " + address);
  } else {
    metric = metrics.handlerRegistered(address, repliedAddress);
  }
}

void unregister();
void unregister(Handler<AsyncResult<Void>> completionHandler);

private void doUnregister(Handler<AsyncResult<Void>> completionHandler, boolean callEndHandler) {
  if (timeoutID != -1) {
    vertx.cancelTimer(timeoutID);
  }
  if (endHandler != null && callEndHandler) {
    Handler<Void> theEndHandler = endHandler;
    Handler<AsyncResult<Void>> handler = completionHandler;
    completionHandler = ar -> {
      theEndHandler.handle(null);
      if (handler != null) {
        handler.handle(ar);
      }
    };
  }
  if (registered) {
    registered = false;
    eventBus.removeRegistration(address, this, completionHandler);
  } else {
    callCompletionHandlerAsync(completionHandler);
  }
  registered = false;
}

protected <T> void removeRegistration(String address, HandlerRegistration<T> handler, Handler<AsyncResult<Void>> completionHandler) {
  HandlerHolder holder = removeLocalRegistration(address, handler);
  removeRegistration(holder, address, completionHandler);
}
protected <T> void removeRegistration(HandlerHolder handlerHolder, String address,
                                      Handler<AsyncResult<Void>> completionHandler) {
  callCompletionHandlerAsync(completionHandler);
}
protected <T> HandlerHolder removeLocalRegistration(String address, HandlerRegistration<T> handler) {
  Handlers handlers = handlerMap.get(address);
  HandlerHolder lastHolder = null;
  if (handlers != null) {
    synchronized (handlers) {
      int size = handlers.list.size();
      // Requires a list traversal. This is tricky to optimise since we can't use a set since
      // we need fast ordered traversal for the round robin
      for (int i = 0; i < size; i++) {
        HandlerHolder holder = handlers.list.get(i);
        if (holder.getHandler() == handler) {
          handlers.list.remove(i);
          holder.setRemoved();
          if (handlers.list.isEmpty()) {
            handlerMap.remove(address);
            lastHolder = holder;
          }
          holder.getContext().removeCloseHook(new HandlerEntry<>(address, holder.getHandler()));
          break;
        }
      }
    }
  }
  return lastHolder;
}

@Override
public <T> EventBus send(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler) {
  sendOrPubInternal(createMessage(true, address, options.getHeaders(), message, options.getCodecName()), options, replyHandler);
  return this;
}
@Override
public EventBus publish(String address, Object message, DeliveryOptions options) {
  sendOrPubInternal(createMessage(false, address, options.getHeaders(), message, options.getCodecName()), options, null);
  return this;
}

protected MessageImpl createMessage(boolean send, String address, MultiMap headers, Object body, String codecName) {
  Objects.requireNonNull(address, "no null address accepted");
  MessageCodec codec = codecManager.lookupCodec(body, codecName);
  @SuppressWarnings("unchecked")
  MessageImpl msg = new MessageImpl(address, null, headers, body, codec, send, this);
  return msg;
}

public MessageImpl(String address, String replyAddress, MultiMap headers, U sentBody,
                   MessageCodec<U, V> messageCodec,
                   boolean send, EventBusImpl bus) {
  this.messageCodec = messageCodec; // Codec
  this.address = address; // 发送目标地址
  this.replyAddress = replyAddress; // 回复地址
  this.headers = headers; // header
  this.sentBody = sentBody; // 发送的对象
  this.send = send; // 是否为点对点模式
  this.bus = bus; // 相关的Event Bus实例
}

private <T> void sendOrPubInternal(MessageImpl message, DeliveryOptions options,
                                   Handler<AsyncResult<Message<T>>> replyHandler) {
  checkStarted();
  HandlerRegistration<T> replyHandlerRegistration = createReplyHandlerRegistration(message, options, replyHandler);
  SendContextImpl<T> sendContext = new SendContextImpl<>(message, options, replyHandlerRegistration);
  sendContext.next();
}

private <T> HandlerRegistration<T> createReplyHandlerRegistration(MessageImpl message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler) {
  if (replyHandler != null) {
    long timeout = options.getSendTimeout();
    String replyAddress = generateReplyAddress();
    message.setReplyAddress(replyAddress);
    Handler<Message<T>> simpleReplyHandler = convertHandler(replyHandler);
    HandlerRegistration<T> registration =
      new HandlerRegistration<>(vertx, metrics, this, replyAddress, message.address, true, replyHandler, timeout);
    registration.handler(simpleReplyHandler);
    return registration;
  } else {
    return null;
  }
}

private final AtomicLong replySequence = new AtomicLong(0);
protected String generateReplyAddress() {
  return Long.toString(replySequence.incrementAndGet());
}

eventBus.addInterceptor(sc -> {
  // 一些处理逻辑
  sc.next(); // 调用下一个拦截器
});

protected class SendContextImpl<T> implements SendContext<T> {
  public final MessageImpl message;
  public final DeliveryOptions options;
  public final HandlerRegistration<T> handlerRegistration;
  public final Iterator<Handler<SendContext>> iter;
  public SendContextImpl(MessageImpl message, DeliveryOptions options, HandlerRegistration<T> handlerRegistration) {
    this.message = message;
    this.options = options;
    this.handlerRegistration = handlerRegistration;
    this.iter = interceptors.iterator();
  }
  @Override
  public Message<T> message() {
    return message;
  }
  @Override
  public void next() {
    if (iter.hasNext()) {
      Handler<SendContext> handler = iter.next();
      try {
        handler.handle(this);
      } catch (Throwable t) {
        log.error("Failure in interceptor", t);
      }
    } else {
      sendOrPub(this);
    }
  }
  @Override
  public boolean send() {
    return message.send();
  }
}

protected <T> void deliverMessageLocally(SendContextImpl<T> sendContext) {
  if (!deliverMessageLocally(sendContext.message)) {
    // no handlers
    metrics.replyFailure(sendContext.message.address, ReplyFailure.NO_HANDLERS);
    if (sendContext.handlerRegistration != null) {
      sendContext.handlerRegistration.sendAsyncResultFailure(ReplyFailure.NO_HANDLERS, "No handlers for address "
                                                             + sendContext.message.address);
    }
  }
}

protected <T> boolean deliverMessageLocally(MessageImpl msg) {
  msg.setBus(this);
  Handlers handlers = handlerMap.get(msg.address());
  if (handlers != null) {
    if (msg.send()) {
      //Choose one
      HandlerHolder holder = handlers.choose();
      metrics.messageReceived(msg.address(), !msg.send(), isMessageLocal(msg), holder != null ? 1 : 0);
      if (holder != null) {
        deliverToHandler(msg, holder);
      }
    } else {
      // Publish
      metrics.messageReceived(msg.address(), !msg.send(), isMessageLocal(msg), handlers.list.size());
      for (HandlerHolder holder: handlers.list) {
        deliverToHandler(msg, holder);
      }
    }
    return true;
  } else {
    metrics.messageReceived(msg.address(), !msg.send(), isMessageLocal(msg), 0);
    return false;
  }
}

private <T> void deliverToHandler(MessageImpl msg, HandlerHolder<T> holder) {
  // Each handler gets a fresh copy
  @SuppressWarnings("unchecked")
  Message<T> copied = msg.copyBeforeReceive();
  if (metrics.isEnabled()) {
    metrics.scheduleMessage(holder.getHandler().getMetric(), msg.isLocal());
  }
  holder.getContext().runOnContext((v) -> {
    // Need to check handler is still there - the handler might have been removed after the message were sent but
    // before it was received
    try {
      if (!holder.isRemoved()) {
        holder.getHandler().handle(copied);
      }
    } finally {
      if (holder.isReplyHandler()) {
        holder.getHandler().unregister();
      }
    }
  });
}

@Override
public void handle(Message<T> message) {
  Handler<Message<T>> theHandler;
  synchronized (this) {
    if (paused) {
      if (pending.size() < maxBufferedMessages) {
        pending.add(message);
      } else {
        if (discardHandler != null) {
          discardHandler.handle(message);
        } else {
          log.warn("Discarding message as more than " + maxBufferedMessages + " buffered in paused consumer");
        }
      }
      return;
    } else {
      if (pending.size() > 0) {
        pending.add(message);
        message = pending.poll();
      }
      theHandler = handler;
    }
  }
  deliver(theHandler, message);
}

private void deliver(Handler<Message<T>> theHandler, Message<T> message) {
  checkNextTick();
  boolean local = true;
  if (message instanceof ClusteredMessage) {
    // A bit hacky
    ClusteredMessage cmsg = (ClusteredMessage)message;
    if (cmsg.isFromWire()) {
      local = false;
    }
  }
  String creditsAddress = message.headers().get(MessageProducerImpl.CREDIT_ADDRESS_HEADER_NAME);
  if (creditsAddress != null) {
    eventBus.send(creditsAddress, 1);
  }
  try {
    metrics.beginHandleMessage(metric, local);
    theHandler.handle(message);
    metrics.endHandleMessage(metric, null);
  } catch (Exception e) {
    log.error("Failed to handleMessage", e);
    metrics.endHandleMessage(metric, e);
    throw e;
  }
}

private synchronized void checkNextTick() {
  if (!pending.isEmpty()) {
    handlerContext.runOnContext(v -> {
      Message<T> message;
      Handler<Message<T>> theHandler;
      synchronized (HandlerRegistration.this) {
        if (paused || (message = pending.poll()) == null) {
          return;
        }
        theHandler = handler;
      }
      deliver(theHandler, message);
    });
  }
}

private int maxSize = DEFAULT_WRITE_QUEUE_MAX_SIZE;
private int credits = DEFAULT_WRITE_QUEUE_MAX_SIZE;

private synchronized <R> void doSend(T data, Handler<AsyncResult<Message<R>>> replyHandler) {
  if (credits > 0) {
    credits--;
    if (replyHandler == null) {
      bus.send(address, data, options);
    } else {
      bus.send(address, data, options, replyHandler);
    }
  } else {
    pending.add(data);
  }
}

public MessageProducerImpl(Vertx vertx, String address, boolean send, DeliveryOptions options) {
  this.vertx = vertx;
  this.bus = vertx.eventBus();
  this.address = address;
  this.send = send;
  this.options = options;
  if (send) {
    String creditAddress = UUID.randomUUID().toString() + "-credit";
    creditConsumer = bus.consumer(creditAddress, msg -> {
      doReceiveCredit(msg.body());
    });
    options.addHeader(CREDIT_ADDRESS_HEADER_NAME, creditAddress);
  } else {
    creditConsumer = null;
  }
}

// 位于HandlerRegistration类的deliver函数中
String creditsAddress = message.headers().get(MessageProducerImpl.CREDIT_ADDRESS_HEADER_NAME);
if (creditsAddress != null) {
  eventBus.send(creditsAddress, 1);
}