Kafka请求处理模块（六）：SocketServer的 KafkaRequestHandler 与 KafkaRequestHandlerPool

KafkaRequestHandlerPool 是真正处理 Kafka 请求的地方。它有以下组件

• KafkaRequestHandler：请求处理线程类。每个请求处理线程实例，负责从 SocketServer 的 RequestChannel 的请求队列中获取请求对象，并进行处理。
• KafkaRequestHandlerPool：请求处理线程池，负责创建、维护、管理和销毁下辖的请求处理线程。
• BrokerTopicMetrics：Broker 端与主题相关的监控指标的管理类。
• BrokerTopicStats（C）：定义 Broker 端与主题相关的监控指标的管理操作。
• BrokerTopicStats（O）：BrokerTopicStats 的伴生对象类，定义 Broker 端与主题相关的监控指标，比如常见的 MessagesInPerSec 和 MessagesOutPerSec 等。

KafkaRequestHandler

是I/O 线程，负责处理 Processor 线程下发的 Request 对象。KafkaRequestHandlerPool：创建和管理一组 KafkaRequestHandler 线程。它的定义如下

class KafkaRequestHandler(id: Int, // id: I/O线程序号，请求处理线程的序号，类似于 Processor 线程的 ID 序号，仅仅用于标识这是线程池中的第几个线程。
                          brokerId: Int, // brokerId：所在Broker序号，即broker.id值
                          val aggregateIdleMeter: Meter,
                          val totalHandlerThreads: AtomicInteger, // totalHandlerThreads：I/O线程池大小
                          val requestChannel: RequestChannel, // requestChannel：请求处理通道，Kafka 在构造 KafkaRequestHandler 实例时，
						  //必须关联 SocketServer 组件中的 RequestChannel 实例，也就是说，要让 I/O 线程能够找到请求被保存的地方。
                          apis: KafkaApis, // apis：KafkaApis类，用于真正实现请求处理逻辑的类
                          time: Time) extends Runnable with Logging {
						  }

KafkaRequestHandler的run方法如下：

  def run(): Unit = {
    // 只要该线程尚未关闭，循环运行处理逻辑
    while (!stopped) {
      // We use a single meter for aggregate idle percentage for the thread pool.
      // Since meter is calculated as total_recorded_value / time_window and
      // time_window is independent of the number of threads, each recorded idle
      // time should be discounted by # threads.
      val startSelectTime = time.nanoseconds
      // 从请求队列中获取下一个待处理的请求
      val req = requestChannel.receiveRequest(300)
      val endTime = time.nanoseconds
      // 统计线程空闲时间
      val idleTime = endTime - startSelectTime
      // 更新线程空闲百分比指标
      aggregateIdleMeter.mark(idleTime / totalHandlerThreads.get)

      req match {
        // 关闭线程请求，说明该 Broker 发起了关闭操作
        case RequestChannel.ShutdownRequest =>
          debug(s"Kafka request handler $id on broker $brokerId received shut down command")
          // 关闭线程
          shutdownComplete.countDown()
          return
        // 普通请求
        case request: RequestChannel.Request =>
          try {
            request.requestDequeueTimeNanos = endTime
            trace(s"Kafka request handler $id on broker $brokerId handling request $request")
            // 由KafkaApis.handle方法执行相应处理逻辑
            apis.handle(request)
          } catch {
            // 如果出现严重错误，立即关闭线程
            case e: FatalExitError =>
              shutdownComplete.countDown()
              Exit.exit(e.statusCode)
            // 如果是普通异常，记录错误日志
            case e: Throwable => error("Exception when handling request", e)
          } finally {
            // 释放请求对象占用的内存缓冲区资源
            request.releaseBuffer()
          }

        case null => // continue
      }
    }
    shutdownComplete.countDown()
  }

KafkaRequestHandlerPool

KafkaRequestHandlerPool 线程池的实现。它是管理 I/O 线程池的，首先看他的定义

class KafkaRequestHandlerPool(val brokerId: Int, // brokerId：所属Broker的序号，即broker.id值
                              val requestChannel: RequestChannel, // requestChannel：SocketServer组件下的RequestChannel对象，SocketServer 的请求处理通道，它下辖的请求队列为所有 I/O 线程所共享
                              val apis: KafkaApis, // api：KafkaApis类，实际请求处理逻辑类
                              time: Time,
                              numThreads: Int, // numThreads：I/O线程池初始大小。线程池中的初始线程数量。KafkaRequestHandler 线程的数量
                              // 它是 Broker 端参数 num.io.threads 的值。目前，Kafka 支持动态修改 I/O 线程池的大小，
                              // 因此，这里的 numThreads 是初始线程数，调整后的 I/O 线程池的实际大小可以和 numThreads 不一致。
                              requestHandlerAvgIdleMetricName: String,
                              logAndThreadNamePrefix : String) extends Logging with KafkaMetricsGroup {
  // I/O线程池大小
  private val threadPoolSize: AtomicInteger = new AtomicInteger(numThreads)
  /* a meter to track the average free capacity of the request handlers */
  private val aggregateIdleMeter = newMeter(requestHandlerAvgIdleMetricName, "percent", TimeUnit.NANOSECONDS)

  this.logIdent = "[" + logAndThreadNamePrefix + " Kafka Request Handler on Broker " + brokerId + "], "
  // I/O线程池
  val runnables = new mutable.ArrayBuffer[KafkaRequestHandler](numThreads)
}

createHandler 方法

当线程池初始化时，Kafka 使用下面这段代码批量创建线程，并将它们添加到线程池中

  def createHandler(id: Int): Unit = synchronized {
    // 创建KafkaRequestHandler实例并加入到runnables中
    runnables += new KafkaRequestHandler(id, brokerId, aggregateIdleMeter, threadPoolSize, requestChannel, apis, time)
    // 启动KafkaRequestHandler线程
    KafkaThread.daemon(logAndThreadNamePrefix + "-kafka-request-handler-" + id, runnables(id)).start()
  }

resizeThreadPool 方法
resizeThreadPool 这个方法的目的是，把 I/O 线程池的线程数重设为指定的数值。

  def resizeThreadPool(newSize: Int): Unit = synchronized {
    val currentSize = threadPoolSize.get
    info(s"Resizing request handler thread pool size from $currentSize to $newSize")
    if (newSize > currentSize) {
      // 该方法首先获取当前线程数量。如果目标数量比当前数量大，就利用刚才说到的 createHandler 方法将线程数补齐到目标值 newSize
      for (i <- currentSize until newSize) {
        createHandler(i)
      }
    } else if (newSize < currentSize) {
      // 否则的话，就将多余的线程从线程池中移除，并停止它们
      for (i <- 1 to (currentSize - newSize)) {
        runnables.remove(currentSize - i).stop()
      }
    }
    // 最后，把标识线程数量的变量 threadPoolSize 的值调整为目标值 newSize。
    threadPoolSize.set(newSize)
  }

SocketServer中KafkaRequestHandlerPool 是真正处理 Kafka 请求的地方，它的流程如下。
第 1 步：Clients 或其他 Broker 发送请求给 Acceptor 线程，这个代码参考Acceptor的run方法。
第 2 & 3 步：Processor 线程处理请求，并放入请求队列，参考Process中的processCompletedReceives代码
第 4 步：I/O 线程处理请求：见上面KafkaRequestHandler的run方法代码，KafkaRequestHandler 线程循环地从请求队列中获取 Request 实例，然后交由 KafkaApis 的 handle 方法，执行真正的请求处理逻辑，KafkaApis 在下一篇博客介绍。
第 5 步：KafkaRequestHandler 线程将 Response 放入 Processor 线程的 Response 队列，这一步的工作也是由 KafkaApis 类完成。当然，这最后依然是由 KafkaRequestHandler 线程来完成的。
第 6 步：Processor 线程发送 Response 给 Request 发送方，代码见Processor 线程的 processNewResponses 方法