docs: @Override
      protected boolean performRequest() {
  
          SocketChannel sc = null;
          boolean closeOnError = false;
  
          // If we were woken up because we have work to do, do it.
          Set<SelectionKey> keySet = this.selector.selectedKeys();
          Iterator<SelectionKey> keyIterator = keySet.iterator();
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(this, tc, "performRequest - processing " + keySet.size() + " items");
          }
  
          while (keyIterator.hasNext()) {
              closeOnError = false;
  
              // If we get exceptions repeatedly, we may need to take a break for a number of reasons
              if (numExceptions >= 3100) {
                  // if we don't recover after 290 more seconds, wait for 10 minutes
                  if (pauseAccept()) {
                      resetExceptions(); // clear exceptions if we weren't interrupted
                  }
                  continue;
              } else if (numExceptions >= 200) {
                  // if we get exceptions repeatedly, wait a tenth to give
                  // other threads some time. It should take about 10 seconds for
                  // us to get up to 200 exceptions (via trace analysis).
                  if (numExceptions == 1500) {
                      FFDCFilter.processException(new Exception("TCP channel has received 1500 exceptions in a row on the accept selector"),
                                                  getClass().getName(), "101", this);
                  }
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException ie) {
                      // ignore it
                  }
              }
  
              // PK40415 - change audit handling of errors
              SelectionKey key = keyIterator.next();
              TCPPort endPoint = (TCPPort) key.attachment();
              TCPChannel tcpChannel = endPoint.getTCPChannel();
  
              try {
                  // safe remove from set while iterating
                  keyIterator.remove();
  
                  // perform accept
                  ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
  
                  try {
                      sc = serverSocketChannel.accept();
  
                      // Configure all inbound channels to be non-blocking
                      if (sc != null) {
                          sc.configureBlocking(false);
                      }
  
                  } catch (IOException ioe) {
                      incrementExceptions();
                      this.numAcceptIOExceptions++;
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                          Tr.event(this, tc, "TCP Channel: " + tcpChannel.getExternalName() + " caught IOException doing accept: " + ioe + " total=" + numExceptions + " count="
                                             + numAcceptIOExceptions);
                      }
                      // Since we could be monitoring several serverSocketChannels, we need
                      // to continue processing even though we got an IOException on this
                      // serverSocketChannel.
                      continue;
                  }
  
                  // sometimes the accept can return null. This seems to happen when
                  // there is a network problem, and we got notified it was ready to
                  // accept, but when we went to do the accept we couldn't complete the accept. If
                  // this happens, just skip this and go on
                  if (sc == null) {
                      incrementExceptions();
                      this.numAcceptNulls++;
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                          Tr.event(this, tc, "TCP Channel: " + tcpChannel.getExternalName() + " accept() returned null, total=" + numExceptions + " count=" + numAcceptNulls);
                      }
                      continue;
                  }
  
                  Socket socket = sc.socket();
                  if (!testSocket(sc)) {
                      continue;
                  }
                  closeOnError = true;
  
                  if (!tcpChannel.verifyConnection(socket)) {
                      closeSocketChannel(sc);
  
                      // if we made it this far, then the accept worked without exceptions
                      if (0 < this.numExceptions) {
                          resetExceptions();
                      }
                      continue;
                  }
  
                  SocketIOChannel ioSocket = null;
                  try {
                      ioSocket = tcpChannel.createInboundSocketIOChannel(sc);
                  } catch (IOException ioe) {
                      // no FFDC required
                      incrementExceptions();
                      this.numConfigureIOExceptions++;
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                          Tr.event(this, tc, "IOException caught while configuring socket: " + ioe + ", total=" + numExceptions + " count=" + numConfigureIOExceptions);
                      }
                      closeSocketChannel(sc);
                      continue;
                  }
                  endPoint.processNewConnection(ioSocket);
  
              } catch (CancelledKeyException cke) {
                  // no FFDC required
                  // Should only get this if the socket was closed. Therefore
                  // log error and continue processing
                  incrementExceptions();
                  this.numCancelledKeys++;
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                      Tr.event(this, tc, "Cancelled key exception found, cke=" + cke + " total=" + numExceptions + " count=" + numCancelledKeys);
                  }
                  continue;
              } catch (Throwable t) {
                  // don't leak sockets if we can't proceed after the accept
                  if (closeOnError) {
                      closeSocketChannel(sc);
                  }
                  // the catcher of the RTE will do the FFDC
                  throw new RuntimeException(t);
              }
  
              // if we made it this far, then the accept worked without exceptions
              if (0 < this.numExceptions) {
                  resetExceptions();
              }
          } // end-while
          return false;
      }