docs: @Override
      protected void updateSelector() {
          final Queue<Object> queue = getWorkQueue();
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(this, tc, "updateSelector - processing " + queue.size() + " items");
          }
          EndPointActionInfo work = null;
  
          while (!queue.isEmpty()) {
              work = (EndPointActionInfo) queue.remove();
  
              // If we are in check for startup mode, we need to see if the server has completely started yet.
  //            if (this.checkStartup) {
  //                // need to get the Channel Framework thread which is starting channels on it's way, so notify now
  //                synchronized (work.syncObject) {
  //                    work.syncObject.notify();
  //                }
  //
  //                // then call into the CHFWBundle and wait till it says the server is all the way started
  //                // before continuing with the normal processing
  //                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
  //                    Tr.debug(this, tc, "updateSelector will wait for server to completely start.  this hashcode is: " + this.hashCode());
  //                }
  //
  //                CHFWBundle.waitServerCompletelyStarted();
  //
  //                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
  //                    Tr.debug(this, tc, "updateSelector wait completed");
  //                }
  //
  //                // only do this once for acceptor thread startup
  //                this.checkStartup = false;
  //            }
  
              if (work.action == NBAccept.REGISTER_ENDPOINT) {
                  try {
                      ServerSocket serverSocket = work.endPoint.getServerSocket();
                      // Configure all inbound channels to be non-blocking
                      serverSocket.getChannel().configureBlocking(false);
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                          Tr.event(this, tc, "Registering: " + serverSocket);
                      }
                      // Add a new listener socket in to the selector.
                      serverSocket.getChannel().register(selector, SelectionKey.OP_ACCEPT, work.endPoint);
                      ++usageCount;
                  } catch (Throwable t) {
                      FFDCFilter.processException(t, getClass().getName() + ".updateSelector", "101", this, new Object[] { work });
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                          Tr.event(this, tc, "Error registering port(" + work.endPoint.getListenPort() + "); " + t);
                      }
                  }
  
                  synchronized (work.syncObject) {
                      work.syncObject.notify();
                  }
  
              } else if (work.action == NBAccept.REMOVE_ENDPOINT) {
                  try {
                      ServerSocket serverSocket = work.endPoint.getServerSocket();
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                          Tr.event(this, tc, "Removing: " + serverSocket);
                      }
                      // cancel the key. Shouldn't need to do this, but there is a bug on HP
                      // so we will just do it regardless of OS
                      serverSocket.getChannel().keyFor(selector).cancel();
                      // force selector to process key cancel before continuing
                      selector.selectNow();
                      --usageCount;
                      if (usageCount <= 0) {
                          shutDown();
                      }
  
                  } catch (Throwable t) {
                      FFDCFilter.processException(t, getClass().getName() + ".updateSelector", "102", this, new Object[] { work });
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                          Tr.event(this, tc, "Error removing port(" + work.endPoint.getListenPort() + "); " + t);
                      }
                  }
  
                  synchronized (work.syncObject) {
                      work.syncObject.notify();
                  }
              }
          } // process all items on the work queue
      }