docs: private void reclaimConnections() {
  
          if (tc.isEntryEnabled()) {
              Tr.entry(this, tc, "reclaimConnections");
          }
          if (totalConnectionCount.get() == 0) {
              /*
               * If there are no connection, we have nothing to reclaim
               */
              if (tc.isEntryEnabled()) {
                  Tr.exit(this, tc, "reclaimConnections", "Total connection count is zero");
              }
              return;
          }
  
          // This is only used for debug information
          int totalNumberOfConnectionRemoved = 0;
  
          /*
           * Look through the free pools for expired Aged and UnusedTimeout values
           */
          for (int j = 0; j < maxFreePoolHashSize; ++j) {
              synchronized (freePool[j].freeConnectionLockObject) {
                  boolean removemcw = false;
                  int mcwlSize = freePool[j].mcWrapperList.size();
                  for (int k = 0; k < mcwlSize; ++k) {
                      MCWrapper mcw = (MCWrapper) freePool[j].mcWrapperList.get(k);
                      if (!removemcw && agedTimeout != -1) {
                          if (mcw.hasAgedTimedOut(agedTimeoutMillis)) {
                              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                  Tr.debug(this, tc, "Aged timeout reclaim connection " + mcw);
                              }
                              removemcw = true;
                          }
                      }
                      if (!removemcw && unusedTimeout != -1) {
                          if (mcw.hasIdleTimedOut(unusedTimeout * 1000)
                              && (this.totalConnectionCount.get() > minConnections)) {
                              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                  Tr.debug(this, tc, "Unused timeout reclaim connection " + mcw);
                              }
                              removemcw = true;
                          }
                      }
  
                      if (removemcw) {
                          mcWrappersToDestroy.add(mcw);
                          this.totalConnectionCount.decrementAndGet();
                          removemcw = false;
                      }
                  } // end of for k loop
                  for (int k = 0; k < mcWrappersToDestroy.size(); ++k) {
                      freePool[j].removeMCWrapperFromList(
                                                          mcWrappersToDestroy.get(k),
                                                          mcWrapperDoesExistInFreePool,
                                                          synchronizedAllReady,
                                                          dontNotifyWaiter, // Notifies will be done after cleanupAndDestroyMCWrapper
                                                          // processing
                                                          dontDecrementTotalCounter);
                  }
  
              } // end of synchronized
              if (localConnection_ != null && needToReclaimTLSConnections()) {
                  boolean reapTLS = false;
                  /*
                   * We can reap connections in the connection pool if we are not in thread sensitive code.
                   */
                  updateToTLSPoolInProgress.set(true); // set to true for pausing pool.
                  synchronized (updateToTLSPoolInProgressLockObject) {
                      try {
                          sleep(20);
                      } catch (InterruptedException e) {
                      }
                      if (activeTLSRequest.get() > 0) {
                          try {
                              sleep(100);
                          } catch (InterruptedException e) {
                          }
                          if (activeTLSRequest.get() > 0) {
                              // We can not purge tls
                              if (tc.isDebugEnabled()) {
                                  Tr.debug(this, tc, "To many active requests to search tls, active request value is " + activeRequest.get());
                              }
                          } else {
                              reapTLS = true;
                          }
                      } else {
                          reapTLS = true;
                      }
                      if (reapTLS) {
                          if (tc.isDebugEnabled()) {
                              Tr.debug(this, tc, "Searching tls for a connections to reap.");
                          }
  
                          Iterator<Entry<MCWrapper, ArrayList<MCWrapper>>> it = tlsArrayLists.entrySet().iterator();
                          while (it.hasNext()) {
                              Entry<MCWrapper, ArrayList<MCWrapper>> e = it.next();
                              MCWrapper mcw = e.getKey();
                              if (mcw.getPoolState() == MCWrapper.ConnectionState_freeTLSPool) {
                                  ArrayList<MCWrapper> mh = e.getValue();
                                  if (agedTimeout != -1) {
                                      if (mcw.hasAgedTimedOut(agedTimeoutMillis)) {
                                          mh.remove(mcw);
                                          tlsArrayLists.remove(mcw);
                                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                              ((com.ibm.ejs.j2c.MCWrapper) mcw).setThreadID(((com.ibm.ejs.j2c.MCWrapper) mcw).getThreadID() + "-reclaim-removed");
                                              Tr.debug(this, tc, "removed mcWrapper from thread local " + mcw);
                                          }
                                          mcw.setPoolState(MCWrapper.ConnectionState_noPool);
                                          mcWrappersToDestroy.add(mcw);
                                          this.totalConnectionCount.decrementAndGet();
                                          continue;
                                      }
                                  }
                                  if (unusedTimeout != -1) {
                                      if (mcw.hasIdleTimedOut(unusedTimeout * 1000)
                                          && (this.totalConnectionCount.get() > minConnections)) {
                                          mh.remove(mcw);
                                          tlsArrayLists.remove(mcw);
                                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                              ((com.ibm.ejs.j2c.MCWrapper) mcw).setThreadID(((com.ibm.ejs.j2c.MCWrapper) mcw).getThreadID() + "-reclaim-removed");
                                              Tr.debug(this, tc, "removed mcWrapper from thread local " + mcw);
                                          }
                                          mcw.setPoolState(MCWrapper.ConnectionState_noPool);
                                          mcWrappersToDestroy.add(mcw);
                                          this.totalConnectionCount.decrementAndGet();
                                      }
                                  }
                              }
                          }
                      }
                      updateToTLSPoolInProgress.set(false); // set to false for releasing pool.
                      updateToTLSPoolInProgressLockObject.notifyAll();
                  }
              }
  
              MCWrapper mcw;
              int destroyListSize = mcWrappersToDestroy.size();
              totalNumberOfConnectionRemoved = totalNumberOfConnectionRemoved + destroyListSize;
              for (int k = destroyListSize; k > 0; --k) {
                  mcw = mcWrappersToDestroy.remove(k - 1);
                  mcw.setInSharedPool(false); // : This mcwrapper is not in shared pool.
                  freePool[j].cleanupAndDestroyMCWrapper(mcw);
              }
              for (int k = 0; k < destroyListSize; ++k) { // free one connection at
                  //  at a time.
                  synchronized (waiterFreePoolLock) {
  
                      if (waiterCount > 0) {
                          // there are requests waiting, so notify one of them
                          waiterFreePoolLock.notify();
                      }
                  } // end sync
              }
          } // end for (int j
          if (tc.isEntryEnabled()) {
              if (tc.isDebugEnabled()) {
                  // This information should only be printed if tc.isEntryEnabled()
                  // and tc.isDebugEnabled()
                  if (totalNumberOfConnectionRemoved > 0) {
                      Tr.debug(
                               tc,
                               "Total number of connections removed are " + totalNumberOfConnectionRemoved);
                  } else {
                      Tr.debug(this, tc, "No connection were removed");
                  }
                  Tr.debug(this, tc, "Current state of pool:");
                  Tr.debug(this, tc, this.toString());
              }
              Tr.exit(this, tc, "reclaimConnections");
          }
      }