public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
public void remove(ReaperElement reaperElement) { if(pendingInsertions.remove(reaperElement) != null) { return; } // we missed finding it in the unsorted set - perhaps it has already been copied to the sorted set... synchronized(this) { removeSorted(reaperElement); } }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }
/** * @param reaperElement the reaper element to reorder in the sorted set. * @param delayMillis the amount of time to increment the element's timeout by. * @return the new soonest timeout in the set (not necessarily that of the reordered element) */ public synchronized long reorder(ReaperElement reaperElement, long delayMillis) { // assume it must be in the sorted list, as it was likely obtained via getFirst... removeSorted(reaperElement); // we could add delay to the original timeout, but using current time is probably safer. reaperElement.setAbsoluteTimeout((System.currentTimeMillis() + delayMillis)); // reinsert into its new position. insertSorted(reaperElement); // getFirst takes care of flushing the pending set for us. return getFirst().getAbsoluteTimeout(); }