docs: public void serverShutDown() throws ResourceException {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.entry(this, tc, "serverShutDown");
          }
  
          connectionPoolShutDown = true;
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(this, tc, "Shutting down pool manager connections in free pool ");
              Tr.debug(this, tc, this.toString());
          }
  
          // Remove parked connection if it exists
          if ((gConfigProps.isSmartHandleSupport() == false)) {
              freePool[0].removeParkedConnection();
          }
          // Reset fatalErrorNotificationTime and remove all free connections
          for (int j = 0; j < gConfigProps.getMaxFreePoolHashSize(); ++j) {
              synchronized (freePool[j].freeConnectionLockObject) {
                  /*
                   * If a connection gets away, by setting fatalErrorNotificationTime will
                   * guaranty when the connection is returned to the free pool, it will be
                   */
                  freePool[j].incrementFatalErrorValue(j);
                  /*
                   * Destroy as many connections as we can in the free pool
                   */
                  if (freePool[j].mcWrapperList.size() > 0) {
                      try { // added a try\catch block
                          freePool[j].cleanupAndDestroyAllFreeConnections();
                      } catch (Exception ex) {
                          if (tc.isDebugEnabled())
                              Tr.debug(this, tc, "Exception during destroy of freepool connection: ", new Object[] { freePool[j], ex });
                      }
                  }
              } // end free lock
          } //end for j
  
          /*
           * we can not process inuse connection by default during server shutdown. This
           * was a change in behavior from 6.0.2 and earlier. By trying to destroy
           * connection that could be
           * used by an application on a different thread, we can encounter unnecessary
           * delays or exceptions that will create pmrs.
           *
           * If this code is needed by some customers, they will be able to enable destroying inuse
           * connection by using a system value enableInuseConnectionDestroy = true. This is not
           * recommenced, since this should not be needed. All applications and services should be
           * stopped before we get this code. If a connection is still inuse by the time we
           * enter this server shutdown code, its very likely the connection is in error and will
           * need to manually be recovered or the service was not stopped first. It should always be
           * understood that manual recovery of XA resource may be needed if connection failure
           * occurs or a process is stopped unexpectedly
           *
           * This may not make sence, but please do not add any inuse connection code unless it can be
           * enabled. In future release, we may what to add this system value to a gui connection pool
           * property. This is the way we should have added this. :-)
           *
           * One other note, if a connection starts to move from the freepool to the inuse pool while
           * we are destroying managed connections, some interesting things may occur. :-) :-). It is
           * like we are going to cause the problem fixed.
           */
          if (enableInuseConnectionDestroy) {
  
              /*
               * Adding the allow connection request = false in an attempt to stop new connection
               * requests from occurring. The error will be misleading, but we will have the
               * stack of the application or service attempting to use a new connections during
               * server shutdown. It should be ok to reuse this var since this should not happen
               * very much.
               */
              allowConnectionRequests = false;
  
              // Managed connections currently in use should be destroyed in order to give the
              // resource adapter a chance to end the transaction branch. Check for in-use connections
              // in both the sharable and unsharable pools.
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  Tr.debug(this, tc, "Destroying sharable, in-use connections");
  
              for (int i = 0; i < maxSharedBuckets; ++i) {
                  synchronized (sharedPool[i].sharedLockObject) {
                      if (sharedPool[i].getMCWrapperListSize() > 0) {
                          MCWrapper[] mcw = sharedPool[i].getMCWrapperList();
  
                          for (int j = 0; j < sharedPool[i].getMCWrapperListSize(); ++j) {
                              try {
                                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                      Tr.debug(this, tc, "Destroying inuse managed connection " + mcw[j]);
                                  }
                                  ManagedConnection mc = mcw[j].getManagedConnectionWithoutStateCheck();
                                  if (mc != null)
                                      mc.destroy();
                              } catch (ResourceException resX) {
                                  // No FFDC needed; we expect some resource adapters will throw errors here.
                                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                      Tr.debug(this, tc, "error during destroy of sharable, in-use connection: ", new Object[] { mcw[j], resX });
                              }
                          } // end loop through the list of connections in the bucket
                      }
                  } // end synchronize on shared pool bucket
              } // end loop through shared pool buckets
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  Tr.debug(this, tc, "Destroying unsharable, in-use connections");
  
              MCWrapper[] mcw = getUnSharedPoolConnections();
  
              for (int j = 0; j < mcw.length; ++j) {
                  try {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(this, tc, "Destroying inuse managed connection " + mcw[j]);
                      }
                      ManagedConnection mc = mcw[j].getManagedConnectionWithoutStateCheck();
                      if (mc != null)
                          mc.destroy();
                  } catch (ResourceException resX) {
                      // No FFDC needed; we expect some resource adapters will throw errors here.
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                          Tr.debug(this, tc, "error during destroy of unsharable in-use connection: ", new Object[] { mcw[j], resX });
                  }
              } // end loop through unsharable, in-use connections
          }
  
          // Ensure that the reap thread has terminated for this pool manager
          // If we don't force closure here, dynamic config changes may cause
          // duplicate reaper threads for the same resource
          synchronized (amLockObject) {
              if (am != null && !am.isDone()) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      Tr.debug(this, tc, "Alarm for pool manager has not completed yet.  Cancelling now.");
                  am.cancel(false);
                  if (am.isDone())
                      alarmThreadCounter.decrementAndGet();
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.exit(this, tc, "serverShutDown");
          }
  
      }