code: private boolean optimisticDelete(
                                      DeleteStack       stack,
                                      Object            deleteKey)
      {
          DeleteNode point = stack.deleteNode();
          int v1 = _vno;
  
          if ((v1&1) != 0)
              return pessimisticNeeded;
  
          synchronized(stack)
          {
          }
  
          try
          {
              findDelete(point, stack, deleteKey);
          }
          catch (NullPointerException npe)
          {
              //No FFDC Code Needed.
              _nullPointerExceptions++;
              return checkForPossibleIndexChange(v1, _vno, npe, "optimisticDelete");
          }
          catch (OptimisticDepthException ode)
          {
              //No FFDC Code Needed.
              _optimisticDepthExceptions++;
              return checkForPossibleIndexChange(v1, _vno, ode, "optimisticDelete");
          }
          synchronized(this)
          {
              if (v1 != _vno)
              {
                  _optimisticDeleteSurprises++;
                  return pessimisticNeeded;
              }
  
              _optimisticDeletes++;
              if (point.wasFound())
              {
                  _vno++;
                  if ((_vno&1) == 1)
                  {
                      finishDelete(point, stack, deleteKey);
                      if (_population <= 0)
                          throw new GBSTreeException("_population = " + _population);
                      _population--;
                  }
                  synchronized(stack)
                  {
                  }
                  _vno++;
              }
          }
          return optimisticWorked;
      }
docs: Optimistic delete from a GBS Tree.
  
  @param stack The DeleteStack used to do the delete.
  @param deleteKey The Object to be deleteed.
  
  @return optimisticWorked if the delete worked, pessimisticNeeded if
  the delete failed due to interference from another thread.