public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.logger.isTraceEnabled()) { tsLogger.logger.trace("TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }
public final void remove(Object control) { if (tsLogger.arjLogger.isDebugEnabled()) { tsLogger.arjLogger.debug(DebugLevel.FUNCTIONS, VisibilityLevel.VIS_PUBLIC, FacilityCode.FAC_ATOMIC_ACTION, "TransactionReaper::remove ( " + control + " )"); } if (control == null) return; ReaperElement key = _timeouts.get(control); if (key == null) { return; } // if a cancellation is in progress then we have to // see it through as we have to ensure that the worker // thread does not get wedged. so we have to tell the // control has gone away. in order to test the status // we need to synchronize on the element before we // synchronize on this so we can ensure that we don't // deadlock ourselves. synchronized (key) { if (key._status != ReaperElement.RUN) { // we are cancelling this TX anyway and need // to track the progress of the cancellation // using this entry so we cnanot remove it return; } removeElementClient(key); } }