docs: public void deleteIfPossible(boolean startAsynchThread)
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "deleteIfPossible", new Boolean(startAsynchThread));
  
          // Lock exclusively to stop any further messages from being added.
          _subscriptionLockManager.lockExclusive();
  
          try
          {
              if (destinationHandler == null)
              {
                  // Get the transaction manager for the message processor
                  PubSubMessageItemStream mis = (PubSubMessageItemStream) getItemStream();
                  destinationHandler = (DestinationHandler) mis.getItemStream();
              }
  
              if (toBeDeleted ||
                  destinationHandler.isToBeDeleted())
              {
                  SIMPTransactionManager txManager = destinationHandler.getTxManager();
                  boolean complete = false;
  
                  try
                  {
                      Statistics statistics = null;
                      try
                      {
                          statistics = getStatistics();
                      } catch (NotInMessageStore e)
                      {
                          // No FFDC Code needed
  
                          // This exception can be thrown if a Durable subscription was on a destination that 
                          // was deleted and it was a durable subscription which was already marked for deletion
                          complete = true;
                          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                              SibTr.exit(tc, "deleteIfPossible", "Subscription already deleted");
                          return;
                      }
  
                      long countOfAvailableItems = statistics.getAvailableItemCount();
  
                      /*
                       * There may be itemreference which is locked for
                       * delivery delay.Those messages must also be deleted.
                       * Hence get the locked message count.Its imp to note that
                       * all the messages will not be deleted only the messages which
                       * are available or messages which are locked for delivery delay
                       * will be deleted.That check is done in removeAllAvailableReferences()
                       * where a DeliveryDelay filter is used.
                       */
                      long countOfLockedMessages = statistics.getLockedItemCount();
  
                      if (countOfAvailableItems > 0 || countOfLockedMessages > 0)
                      {
                          //Remove any available references from the subscription.
                          try
                          {
                              removeAllAvailableReferences();
                          } catch (SIResourceException e1)
                          {
                              // No FFDC code needed
                              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                                  SibTr.exit(tc, "deleteIfPossible", e1);
                              // Exit so finally block run
                              return;
                          }
                      }
  
                      statistics = getStatistics();
  
                      long countOfTotalItems = statistics.getTotalItemCount();
                      if (countOfTotalItems == 0)
                      {
                          //All references are gone.  The subscription can be removed.
  
                          if (destinationHandler.isToBeDeleted())
                          {
                              //It may now be possible to clean up the destination.  Have a go!
                              destinationHandler.getDestinationManager().markDestinationAsCleanUpPending(destinationHandler);
                          }
  
                          try
                          {
                              PubSubMessageItemStream parentItemStream = (PubSubMessageItemStream) getItemStream();
                              remove(txManager.createAutoCommitTransaction(), NO_LOCK_ID);
                              parentItemStream.decrementReferenceStreamCount();
                              complete = true;
                          } catch (MessageStoreException e)
                          {
                              FFDCFilter.processException(
                                                          e,
                                                          "com.ibm.ws.sib.processor.impl.store.itemstreams.SubscriptionItemStream.deleteIfPossible",
                                                          "1:364:1.54",
                                                          this);
  
                              SibTr.exception(tc, e);
                              SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                                          new Object[] {
                                                        "com.ibm.ws.sib.processor.impl.store.itemstreams.SubscriptionItemStream",
                                                        "1:371:1.54",
                                                        e });
  
                          }
  
                      }
                  } catch (Exception e)
                  {
                      // No FFDC code needed
                      // Log that this exception occured
                      SibTr.exception(tc, e);
                  } finally
                  {
                      if (!complete)
                      {
                          destinationHandler.getDestinationManager().addSubscriptionToDelete(this);
                          if (startAsynchThread)
                              destinationHandler.getDestinationManager().startAsynchDeletion();
                      }
                  }
              }
          } catch (MessageStoreException e)
          {
              FFDCFilter.processException(
                                          e,
                                          "com.ibm.ws.sib.processor.impl.store.itemstreams.SubscriptionItemStream.deleteIfPossible",
                                          "1:400:1.54",
                                          this);
  
              SibTr.exception(tc, e);
              SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                          new Object[] {
                                        "com.ibm.ws.sib.processor.impl.store.itemstreams.SubscriptionItemStream",
                                        "1:407:1.54",
                                        e });
  
          } finally
          {
              // Finally unlock the lock manager
              _subscriptionLockManager.unlockExclusive();
          }
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "deleteIfPossible");
          return;
      }