图解 Kafka 源码之 Sender 线程架构设计

public class KafkaProducer<K, V> implements Producer<K, V> {
    public static final String NETWORK_THREAD_PREFIX = "kafka-producer-network-thread";
    // visible for testing
    @SuppressWarnings("unchecked")
    KafkaProducer(Map<String, Object> configs,Serializer<K> keySerializer,
              Serializer<V> valueSerializer,ProducerMetadata metadata,
              KafkaClient kafkaClient,ProducerInterceptors<K, V> interceptors,Time time) {
        try {
            ...
            this.sender = newSender(logContext, kafkaClient, this.metadata);
            String ioThreadName = NETWORK_THREAD_PREFIX + " | " + clientId;
            this.ioThread = new KafkaThread(ioThreadName, this.sender, true);
            this.ioThread.start();
            ...
            log.debug("Kafka producer started");
        } catch (Throwable t) {
           ...
        }
    }
}

/**
 * The background thread that handles the sending of produce requests to the Kafka cluster. This thread makes metadata
 * requests to renew its view of the cluster and then sends produce requests to the appropriate nodes.
 */
public class Sender implements Runnable {
    /* the state of each nodes connection */
    private final KafkaClient client; // 为 Sender 线程提供管理网络连接进行网络读写
    /* the record accumulator that batches records */
    private final RecordAccumulator accumulator; // 消息仓库累加器
    /* the metadata for the client */
    private final ProducerMetadata metadata; // 生产者元数据
    /* the flag indicating whether the producer should guarantee the message order on the broker or not. */
    private final boolean guaranteeMessageOrder; // 是否保证消息在 broker 端的顺序性 
    /* the maximum request size to attempt to send to the server */
    private final int maxRequestSize; //发送消息最大字节数。  
    /* the number of acknowledgements to request from the server */
    private final short acks; // 生产者的消息发送确认机制
    /* the number of times to retry a failed request before giving up */
    private final int retries; // 发送失败后的重试次数，默认为0次

    /* true while the sender thread is still running */
    private volatile boolean running; // Sender 线程是否还在运行中     
    /* true when the caller wants to ignore all unsent/inflight messages and force close.  */
    private volatile boolean forceClose; // 是否强制关闭，此时会忽略正在发送中的消息。
    /* the max time to wait for the server to respond to the request*/
    private final int requestTimeoutMs; // 等待服务端响应的最大时间,默认30s       
    /* The max time to wait before retrying a request which has failed */
    private final long retryBackoffMs; // 失败重试退避时间      
    /* current request API versions supported by the known brokers */
    private final ApiVersions apiVersions; // 所有 node 支持的 api 版本
    /* all the state related to transactions, in particular the producer id, producer epoch, and sequence numbers */
    private final TransactionManager transactionManager; // 事务管理，这里忽略 后续会有专门一篇讲解事务相关的
    // A per-partition queue of batches ordered by creation time for tracking the in-flight batches
    private final Map<TopicPartition, List<ProducerBatch>> inFlightBatches; // 正在执行发送相关的消息批次集合， key为分区，value是 list<ProducerBatch> 。

/**
  * The main run loop for the sender thread
  */
@Override
public void run() {
        log.debug("Starting Kafka producer I/O thread.");
        // 这里使用 volatile boolean 类型的变量 running，判断 Sender 线程是否在运行状态中。
        // 1. 如果 Sender 线程在运行状态即 running=true，则一直循环调用 runOnce() 方法。
        while (running) {
            try {
                // 将缓冲区的消息发送到 broker。
                runOnce();
            } catch (Exception e) {
                log.error("Uncaught error in kafka producer I/O thread: ", e);
            }
        }
        log.debug("Beginning shutdown of Kafka producer I/O thread, sending remaining records.");
        // 2. 如果（没有强制关闭 && ((消息累加器中还有剩余消息待发送 || 还有等待未响应的消息 ) || 还有事务请求未完成))，则继续发送剩下的消息。
        while (!forceClose && ((this.accumulator.hasUndrained() || this.client.inFlightRequestCount() > 0) || hasPendingTransactionalRequests())) {
            try {
                // 继续执行将剩余的消息发送完毕
                runOnce();
            } catch (Exception e) {
                log.error("Uncaught error in kafka producer I/O thread: ", e);
            }
        }
        // 3. 对进行中的事务进行中断，则继续发送剩下的消息。
        while (!forceClose && transactionManager != null && transactionManager.hasOngoingTransaction()) {
            if (!transactionManager.isCompleting()) {
                log.info("Aborting incomplete transaction due to shutdown");
                transactionManager.beginAbort();
            }
            try {
                runOnce();
            } catch (Exception e) {
                log.error("Uncaught error in kafka producer I/O thread: ", e);
            }
        }
        // 4. 如果强制关闭，则关闭事务管理器、终止消息的追加并清空未完成的批次
        if (forceClose) {
            if (transactionManager != null) {
                log.debug("Aborting incomplete transactional requests due to forced shutdown");
                // 关闭事务管理器
                transactionManager.close();
            }
            log.debug("Aborting incomplete batches due to forced shutdown");
            // 终止消息的追加并清空未完成的批次
            this.accumulator.abortIncompleteBatches();
        }
        // 5. 关闭 NetworkClient
        try {
            this.client.close();
        } catch (Exception e) {
            log.error("Failed to close network client", e);
        }
        log.debug("Shutdown of Kafka producer I/O thread has completed.");
}

/**
 * Run a single iteration of sending
 */
void runOnce() {
        if (transactionManager != null) {
           ... //事务处理方法 后续文章专门讲解 
        }
        // 1. 获取当前时间的时间戳。
        long currentTimeMs = time.milliseconds();
        // 2. 调用 sendProducerData 发送消息,但并非真正的发送，而是把消息缓存在 把消息缓存在 KafkaChannel 的 Send 字段里。下一篇会讲解 NetworkClient。
        long pollTimeout = sendProducerData(currentTimeMs);
        // 3. 读取消息实现真正的网络发送
        client.poll(pollTimeout, currentTimeMs);
}

private long sendProducerData(long now) {
        // 1. 获取元数据
        Cluster cluster = metadata.fetch();
        // get the list of partitions with data ready to send
        // 2. 获取已经准备好的节点以及找不到 Leader 分区对应的节点的主题
        RecordAccumulator.ReadyCheckResult result = this.accumulator.ready(cluster, now);
        // if there are any partitions whose leaders are not known yet, force metadata update
        // 3. 如果主题 Leader 分区对应的节点不存在，则强制更新元数据
        if (!result.unknownLeaderTopics.isEmpty()) {
            // 添加 topic 到没有拉取到元数据的 topic 集合中，并标识需要更新元数据
            for (String topic : result.unknownLeaderTopics)
                this.metadata.add(topic, now);
            ...
            // 针对这个 topic 集合进行元数据更新
            this.metadata.requestUpdate();
        }
        // 4. 循环 readyNodes 并检查客户端与要发送节点的网络是否已经建立好了
        Iterator<Node> iter = result.readyNodes.iterator();
        long notReadyTimeout = Long.MAX_VALUE;
        while (iter.hasNext()) {
            Node node = iter.next();
            // 检查客户端与要发送节点的网络是否已经建立好了
            if (!this.client.ready(node, now)) {
                // 移除对应节点
                iter.remove();
                notReadyTimeout = Math.min(notReadyTimeout, this.client.pollDelayMs(node, now));
            }
        }
        // create produce requests
        // 5. 获取上面返回的已经准备好的节点上要发送的 ProducerBatch 集合
        Map<Integer, List<ProducerBatch>> batches = this.accumulator.drain(cluster, result.readyNodes, this.maxRequestSize, now);
        // 6. 将从消息累加器中读取的数据集，放入正在执行发送相关的消息批次集合中
        addToInflightBatches(batches);
        // 7. 要保证消息的顺序性，即参数 max.in.flight.requests.per.cnotallow=1
        if (guaranteeMessageOrder) {
            // Mute all the partitions drained
            for (List<ProducerBatch> batchList : batches.values()) {
                for (ProducerBatch batch : batchList)
                    // 对 tp 进行 mute，保证只有一个 batch 正在发送
                    this.accumulator.mutePartition(batch.topicPartition);
            }
        }
        // 重置下一批次的过期时间
        accumulator.resetNextBatchExpiryTime();
        // 8. 从正在执行发送数据集合 inflightBatches 中获取过期集合
        List<ProducerBatch> expiredInflightBatches = getExpiredInflightBatches(now);
        // 9. 从 batches 中获取过期集合
        List<ProducerBatch> expiredBatches = this.accumulator.expiredBatches(now);
        // 10. 从 inflightBatches 与 batches 中查找已过期的消息批次(ProducerBatch)，判断批次是否过      期是根据系统当前时间与 ProducerBatch 创建时间之差是否超过120s，过期时间可以通过参数 delivery.timeout.ms 设置。
        expiredBatches.addAll(expiredInflightBatches);

        // 如果过期批次不为空 则输出对应日志
        if (!expiredBatches.isEmpty())
            log.trace("Expired {} batches in accumulator", expiredBatches.size());
        // 11. 处理已过期的消息批次，通知该批消息发送失败并返回给客户端
        for (ProducerBatch expiredBatch : expiredBatches) {
            // 处理当前过期ProducerBatch的回调结果 ProduceRequestResult,并且设置超时异常 new TimeoutException(errorMessage)
            String errorMessage = "Expiring " + expiredBatch.recordCount + " record(s) for " + expiredBatch.topicPartition
                + ":" + (now - expiredBatch.createdMs) + " ms has passed since batch creation";
            // 通知该批消息发送失败并返回给客户端
            failBatch(expiredBatch, -1, NO_TIMESTAMP, new TimeoutException(errorMessage), false);
            // ... 事务管理器的处理忽略
        }
        // 收集统计指标，后续会专门对 Kafka 的 Metrics 进行分析
        sensors.updateProduceRequestMetrics(batches);

        // 设置下一次的发送延时
        long pollTimeout = Math.min(result.nextReadyCheckDelayMs, notReadyTimeout);
        pollTimeout = Math.min(pollTimeout, this.accumulator.nextExpiryTimeMs() - now);
        pollTimeout = Math.max(pollTimeout, 0);
        if (!result.readyNodes.isEmpty()) {
            log.trace("Nodes with data ready to send: {}", result.readyNodes);
            pollTimeout = 0;
        }
        // 12. 发送消息暂存到 NetworkClient send 字段里。
        sendProduceRequests(batches, now);
        return pollTimeout;
}

void runOnce() {
        // 1. 把消息缓存在 KafkaChannel 的 Send 字段里。
        long pollTimeout = sendProducerData(currentTimeMs);
        // 2. 读取消息实现真正的网络发送
        client.poll(pollTimeout, currentTimeMs);
}