docs: public void run()
    {      
      if (tc.isEntryEnabled())
          SibTr.entry(tc, "run");
              
      // Make sure that the unit test is happy for this tread to continue with 
      // an attempted pass at deletions.
      // The unit tests may block this thread at this point, to make sure 
      // we don't delete things immediately. Leads to more determinate behaviour 
      // for the unit tests.
      MPCallsToUnitTestHandler unitTestCallback = MessageProcessor.getMPCallsToUnitTestHandler();
      DestinationManager destinationManager = _messageProcessor.getDestinationManager();
      DestinationIndex destinationIndex = destinationManager.getDestinationIndex();
      LinkIndex linkIndex = destinationManager.getLinkIndex();
  
      SIMPIterator itr = null;
      
      boolean run = true;
              
      try
      {
        //Check if we should synchronize with the unit tests
        if( unitTestCallback != null ) 
          asynchLock = unitTestCallback.getAsynchLock(this);
        synchronized(asynchLock)
        {
          //Check if we should synchronize with the unit tests
          if( unitTestCallback != null )
            unitTestCallback.asyncDeletionThreadReadyToStart(); 
          
          while (run && !isStopping())
          {      
    
            // Venu mock mock
            // no Neighbours for this version of Liberty profile
            /*	
            // Remove any unused Neighbours
            _messageProcessor.getProxyHandler().removeUnusedNeighbours(); */
            
            // Delete any redundant subscriptions
            List subscriptions = (List)(((ArrayList)destinationManager.getSubscriptionsToDelete()).clone());
            SubscriptionItemStream stream = null;
            while (!subscriptions.isEmpty())
            {
              stream = (SubscriptionItemStream)subscriptions.remove(0);      
              cleanupSubscription(stream);
              destinationManager.removeSubscriptionAsDeleted(stream);
            }
                  
            DestinationTypeFilter destFilter = new DestinationTypeFilter();
            destFilter.ALIAS = Boolean.FALSE;
            destFilter.FOREIGN_DESTINATION = Boolean.FALSE;
            destFilter.and = false;
            destFilter.CLEANUP_PENDING = Boolean.TRUE;
            destFilter.DELETE_PENDING = Boolean.TRUE;
            itr = destinationIndex.iterator(destFilter);
            BaseDestinationHandler dh = null;
        
            while (itr.hasNext() && !isStopping())
            {             
                    
              dh = (BaseDestinationHandler)itr.next();
              boolean destinationCleanedUp = cleanUpDestination(dh);
              if (destinationCleanedUp)
              {
                //Success!
                synchronized (destinationIndex)
                {
                  State state = destinationIndex.getState(dh);
                  if(state.isCleanupPending())
                  {
                    destinationIndex.cleanupComplete(dh);
                  }
                  else //DELETE_PENDING
                  {
                    destinationIndex.remove(dh);
                  }
                }
                if (tc.isDebugEnabled())
                  SibTr.debug(tc, "Destination " + dh.getName() + " cleaned up");
              }
              else
              {
                if (tc.isDebugEnabled())
                  SibTr.debug(tc, "Failed to cleanup destination " + dh.getName());
              }
            }
            itr.finished();
            
            LinkTypeFilter linkFilter = new LinkTypeFilter();
            linkFilter.and = false;
            linkFilter.CLEANUP_PENDING = Boolean.TRUE;
            linkFilter.DELETE_PENDING = Boolean.TRUE;
            itr = linkIndex.iterator(linkFilter);
      
            while (itr.hasNext() && !_isStopping)
            {                  
              dh = (BaseDestinationHandler)itr.next();
              boolean destinationCleanedUp = cleanUpDestination(dh);
              if (destinationCleanedUp)
              {
                //Success!
                synchronized(linkIndex)
                {
                  State state = linkIndex.getState(dh);
                  if(state.isCleanupPending())
                  {
                    linkIndex.cleanupComplete(dh);
                  }
                  else //DELETE_PENDING
                  {
                    linkIndex.remove(dh);
                  }
                }
                if (tc.isDebugEnabled())
                  SibTr.debug(tc, "Link " + dh.getName() + " cleaned up");
              }
              else
              {
                if (tc.isDebugEnabled())
                  SibTr.debug(tc, "Failed to cleanup Link " + dh.getName());
              }          
            }      
            itr.finished();
            run = _rerunRequested;
            _rerunRequested = false;
          }
          asynchLock.notifyAll();
        }
      } 
      catch (Exception e ) 
      {      
        // FFDC
        FFDCFilter.processException(e, 
                                    "com.ibm.ws.sib.processor.impl.AsynchDeletionThread.run", 
                                    "1:263:1.50", 
                                    this);
        
        try
        {
          itr.finished();
        }
        catch(Exception e2)
        {
          // No FFDC code needed
          //do nothing!
        }
    
        // Some failure occurred, which we're going to throw on the deletion 
        // thread... to nobody.
        
        // Log warning to the console
    
        //    Report the error to the message processor. It will be ignored
        // if the message processor is running in production code.
        // If in unit test code, a junit error will occur, so we are more
        // aware of such cleanup failures.
        unitTestCallback = MessageProcessor.getMPCallsToUnitTestHandler();
        if( null != unitTestCallback )
        {
          // We're operating inside a unit test
          unitTestCallback.unitTestFailure( 
            "Async background deletion thread failed with an exception ",
            e );
        }
        SIErrorException exToThrow = 
          new SIErrorException( nls.getFormattedMessage(
              "INTERNAL_MESSAGING_ERROR_CWSIP0001",
              new Object[] {
                "com.ibm.ws.sib.processor.impl.AsynchDeletionThread.run",
                "1:298:1.50" }, 
                null), 
              e);  
        SibTr.exception( tc, e );  
        if (tc.isEntryEnabled())
          SibTr.exit(tc, "run");
        throw exToThrow;   
      }
      finally
      {            
        // Prepare to exit. Notify any waiters (i.e perhaps we're in MP.stop() processing) 
        // that we are done and set the isRunning flag to false 
        destinationManager.notifyAsynchDeletionEnd(this);
      }
  
      if (tc.isEntryEnabled())
          SibTr.exit(tc, "run");
    }