docs: @Override
      public void removeRecoverableUnit(long identity) throws LogClosedException, InvalidRecoverableUnitException, InternalLogException, LogIncompatibleException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "removeRecoverableUnit", new Object[] { identity, this });
  
          // If this recovery log instance has been marked as incompatible then throw an exception
          // accordingly.
          if (incompatible())
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", "LogIncompatibleException");
              throw new LogIncompatibleException();
          }
  
          // If this recovery log instance has experienced a serious internal error then prevent this operation from
          // executing.
          if (failed())
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", this);
              throw new InternalLogException(null);
          }
  
          // Ensure the log is actually open.
          if (_logHandle == null)
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", "LogClosedException");
              throw new LogClosedException(null);
          }
  
          // We are going to change the internal data structures by removing a new recoverable unit. Take a shared lock
          // to avoid a clash with the keypoint logic.
          _controlLock.getSharedLock(LOCK_REQUEST_ID_MSRL_REMOVE);
  
          RecoverableUnitImpl recoverableUnit = null;
  
          synchronized (this)
          {
              // REQD Thread safety
              recoverableUnit = removeRecoverableUnitMapEntries(identity);
          }
  
          // If the RecoverableUnit corresponding to 'identity' was not found in the map then throw an exception
          if (recoverableUnit == null)
          {
              try
              {
                  _controlLock.releaseSharedLock(LOCK_REQUEST_ID_MSRL_REMOVE);
              } catch (Exception exc)
              {
                  // We are processing an error condition anyway. Ignore this problem as there is nothing
                  // that can be done about it. The InternalLogException exception indicates to the
                  // original caller that the recovery log service has failed.
                  FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.removeRecoverableUnit", "1165", this);
              }
  
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", "InvalidRecoverableUnitException");
              throw new InvalidRecoverableUnitException(null);
          }
  
          // Inform the recoverable unit that it is being deleted. This enables it to write a "DELETED" entry in the
          // recovery log (unforced) to ensure that a previous instance of this recoverable unit does not get confused with
          // a newer instance (otherwise the recovey logic would have no way of distinguising between older, deleted information
          // and newer recoverable information)
          try
          {
              recoverableUnit.remove();
          } catch (InternalLogException exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.removeRecoverableUnit", "1182", this);
  
              markFailed(exc); /* @MD19484C */
  
              try
              {
                  _controlLock.releaseSharedLock(LOCK_REQUEST_ID_MSRL_REMOVE);
              } catch (Exception exc2)
              {
                  // We are processing an internal failure anyway. Ignore this problem as there is nothing
                  // that can be done about it. The InternalLogException exception indicates to the
                  // original caller that the recovery log service has failed.
                  FFDCFilter.processException(exc2, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.removeRecoverableUnit", "1195", this);
              }
  
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", exc);
              throw exc;
          }
  
          // We have finished updating the internal data structure so release the shared lock.
          try
          {
              _controlLock.releaseSharedLock(LOCK_REQUEST_ID_MSRL_REMOVE);
          } catch (NoSharedLockException exc)
          {
              // In practice this exception will not be generated as we have obtained the shared lock at the top of this method
              // so we should be able to release it here. If this exception is generated then all we can do is throw the
              // InternalLogException exception to indicate a serious problem with the recovery log service.
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.removeRecoverableUnit", "1212", this);
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", "InternalLogException");
              throw new InternalLogException(exc);
          } catch (Throwable exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.removeRecoverableUnit", "1218", this);
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", "InternalLogException");
              throw new InternalLogException(exc);
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "removeRecoverableUnit");
      }