TThreadedSelectorServer模式源码分析

<span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px; background-color: rgb(255, 255, 255);">TThreadedSelectorServer extendsAbstractNonblockingServer</span>

AbstractNonblockingServer extends TServer

 

AbstractNonblockingServer中：

/**
   * Begin accepting connections and processing invocations.
   */
  public void serve() {
    // start any IO threads
    if (!startThreads()) {
      return;
    }
 
    // start listening, or exit
    if (!startListening()) {
      return;
    }
 
    setServing(true);
 
    // this will block while we serve
    waitForShutdown();
 
    setServing(false);
 
    // do a little cleanup
    stopListening();
  }

（1）startThreads()为虚函数，在TThreadedSelectorServer中会实现。其中：

（2）startListening()：服务端开启transport监听。

/**
   * Have the server transport start accepting connections.
   *
   * @return true if we started listening successfully, false if something went
   *         wrong.
   */
  protected boolean startListening() {
    try {
      serverTransport_.listen();
      return true;
    } catch (TTransportException ttx) {
      LOGGER.error("Failed to start listening on server socket!", ttx);
      return false;
    }
  }

（3）setServing(true); 设置服务器工作状态为true

（4）waitForShutdown(); 服务运行时，该方法及以下方法将阻塞。A method that will block until when threads handling the servinghave been shut down.

（5）setServing(false); 设置服务器工作状态为false

（6）stopListening(); 服务端关闭transport监听。Stop listening for connections.

 

继续看TThreadedSelectorServer的startThreads方法。

/**
   * Start the accept and selector threads running to deal with clients.
   *
   * @return true if everything went ok, false if we couldn't start for some
   *         reason.
   */
  @Override
  protected boolean startThreads() {
    try {
      for (int i = 0; i < args.selectorThreads; ++i) {
        selectorThreads.add(new SelectorThread(args.acceptQueueSizePerThread));
      }
      acceptThread = new AcceptThread((TNonblockingServerTransport) serverTransport_,
        createSelectorThreadLoadBalancer(selectorThreads));
      for (SelectorThread thread : selectorThreads) {
        thread.start();
      }
      acceptThread.start();
      return true;
    } catch (IOException e) {
      LOGGER.error("Failed to start threads!", e);
      return false;
    }
  }

SelectorThread：TheSelectorThread(s) will be doing all the selecting on accepted active connections.上面需要注意的SelectorThread和AcceptThread。

AcceptThread：The thread thatselects on the server transport (listen socket) and accepts new connections tohand off to the IO selector threads。

SelectorThread线程启动后，做如下事情：

/**
     * The work loop. Handles selecting (read/write IO), dispatching, and
     * managing the selection preferences of all existing connections.
     */
    public void run() {
      try {
        while (!stopped_) {
          select();
          processAcceptedConnections();
          processInterestChanges();
        }
        for (SelectionKey selectionKey : selector.keys()) {
          cleanupSelectionKey(selectionKey);
        }
      } catch (Throwable t) {
        LOGGER.error("run() exiting due to uncaught error", t);
      } finally {
        // This will wake up the accept thread and the other selector threads
        TThreadedSelectorServer.this.stop();
      }
    }

来看select方法：

/**
     * Select and process IO events appropriately: If there are existing
     * connections with data waiting to be read, read it, buffering until a
     * whole frame has been read. If there are any pending responses, buffer
     * them until their target client is available, and then send the data.
     */
    private void select() {
      try {
        // wait for io events.
        selector.select();

        // process the io events we received
        Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();
        while (!stopped_ && selectedKeys.hasNext()) {
          SelectionKey key = selectedKeys.next();
          selectedKeys.remove();

          // skip if not valid
          if (!key.isValid()) {
            cleanupSelectionKey(key);
            continue;
          }

          if (key.isReadable()) {
            // deal with reads
            handleRead(key);
          } else if (key.isWritable()) {
            // deal with writes
            handleWrite(key);
          } else {
            LOGGER.warn("Unexpected state in select! " + key.interestOps());
          }
        }
      } catch (IOException e) {
        LOGGER.warn("Got an IOException while selecting!", e);
      }
    }

这里主要是用到java的nio技术来处理。

若等到读事件则处理读，等到写事件则处理写。