docs: void force() throws InternalLogException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "force", this);
  
          // Check that the file is actually open
          if (_activeFile == null)
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "force", "InternalLogException");
              throw new InternalLogException(null);
          }
  
          // Attempt to get exclusive lock on the lock object provided by RecoveryLogService
          // to protect access to the isSuspended flag, which is toggled during calls
          // to RecoveryLogService suspend/resume
          synchronized (RLSControllerImpl.SUSPEND_LOCK)
          {
              while (RLSControllerImpl.isSuspended())
              {
                  try
                  {
                      if (tc.isDebugEnabled())
                          Tr.debug(tc, "Waiting for RecoveryLogService to resume");
                      RLSControllerImpl.SUSPEND_LOCK.wait();
                  } catch (InterruptedException exc)
                  {
                      // This exception is received if another thread interrupts this thread by calling this threads 
                      // Thread.interrupt method. The RecoveryLogService class does not use this mechanism for 
                      // breaking out of the wait call - it uses notifyAll to wake up all waiting threads. This
                      // exception should never be generated. If for some reason it is called then ignore it and 
                      // start to wait again.
                      FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.force", "834", this);
                  }
              }
  
              // Check if we've been configured to run in snapshot safe mode
              // With this in place we synchronize all force method calls and
              // take the synchronization performance hit.  The benefit is that we
              // can be sure that the log files will be in a consistent state
              // for snapshotting
              if (Configuration._isSnapshotSafe)
              {
                  _activeFile.force();
              }
          }
  
          //  If we're not configured to be snapshot safe then we
          //  run a slight risk here that a force operation could be called
          //  just after the RecoveryLogService has been called to suspend,
          //  as we're outwith the sync block.
          //  The benefit is that we don't have the synchronization performance 
          //  hit when calling the force method 
          if (!Configuration._isSnapshotSafe)
          {
              _activeFile.force();
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "force");
      }