decrease counter

@param hasExportedInCurrent
972478
private void decrementCounter(Map<String, Boolean> hasExportedInCurrent) {
        //once error, we decrementAndGet the counter
        for (Map.Entry<String, Boolean> entry : hasExportedInCurrent.entrySet()) {
            String protocol = entry.getKey();
            String key = providerConfig.buildKey() + ":" + protocol;
            AtomicInteger cnt = EXPORTED_KEYS.get(key); // 计数器
            if (cnt != null && cnt.get() > 0) {
                cnt.decrementAndGet();
            }
        }
    }
551269
protected void actionDropingOff(double extrp)
    {
        progress -= speed * extrp;
        final int curProgress = (int) Math.floor(progress);

        // Check ended
        if (curProgress <= 0)
        {
            for (final ExtractorListener listener : listeners)
            {
                listener.notifyDroppedOff(resourceType, lastProgress);
            }
            startExtraction();
        }
    }
443448
def decrement_display_ref_count(self, amount: int=1):
        """"""
        assert not self._closed
        self.__display_ref_count -= amount
        for display_data_channel in self.display_data_channels:
            display_data_channel.decrement_display_ref_count(amount)
892366
public void removeExporterEventListener(ExporterEventListener listener) {
		listenerList.remove(listener);
		if (exporter != null) {
			exporter.removeExporterEventListener(listener);
		}
	}
945107
private void remove(PollController conn)
  {
    if (conn == null) {
      return;
    }

    JniSocketImpl socket = (JniSocketImpl) conn.getSocket();
    int nativeFd = socket.getNativeFd();

    if (_lifecycle.isDestroyed()) {
      return;
    }

    _activeCount.incrementAndGet();

    if (nativeFd > 0) {
      try {
        removeNative(_fd, nativeFd);
      } catch (Throwable e) {
        log.log(Level.WARNING, e.toString(), e);
        _lifecycle.toError();
      }
    }
    
    conn.toKeepaliveClose();

    if (_activeCount.decrementAndGet() == 0 && _lifecycle.isDestroyed()) {
      destroy();
    }
  }
796571
public void subtractAll(IntCounter<E> counter) {
    for (E key : map.keySet()) {
      decrementCount(key, counter.getIntCount(key));
    }
  }
445148
final public void decrement(long time, long value) {
        if (!enabled)
            return;

        lastSampleTime = time;
        if (!sync) {
            count -= value;
        } else {
            synchronized (this) {
                count -= value;
            }
        }
    }
238715
public void discard(int count) {
    assert elementsCount >= count;

    elementsCount -= count;
    /* #if ($TemplateOptions.KTypeGeneric) */
    Arrays.fill(buffer, elementsCount, elementsCount + count, null);
    /* #end */
  }
184128
public void incrementCurrentSize() throws SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "incrementCurrentSize");

        if (_currentTran != null)
        {
            _currentTran.incrementCurrentSize();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "incrementCurrentSize");
    }
1098967
public void decrementTargetIncomingTransitionCounts()
    {
        for(Entry<Character, MDAGNode> transitionKeyValuePair: outgoingTransitionTreeMap.entrySet())
            transitionKeyValuePair.getValue().incomingTransitionCount--;
    }
53049
static void removeDetails(Throwable throwable, ExceptionTruncation truncation) {

    if (truncation.isRemoveStacktrace()) {
      throwable.setStackTrace(ExceptionUtil.NO_STACKTRACE);
    }
    if (truncation.isRemoveCause()) {
      getHelper().setCause(throwable, null);
    }
    if (truncation.isRemoveSuppressed()) {
      getHelper().setSuppressed(throwable, null);
    }
  }
1343854
private void decrement() {
		MyData data = (MyData) getData();
		int dataCount = data.getCount();

		if (dataCount > 0) {
			dataCount--;
		}

		data.setCount(dataCount);
	}
691472
function isCounterAfter(counter, currentStateCounter)
{
	const diff = counter - currentStateCounter

	// If the new options are "newer" than the current ones,
	// then they can override them.
	// (also accounts for counter overflow)
	return diff > 0 || (diff < 0 && Math.abs(diff) > MAX_SAFE_INTEGER / 2)
}
867279
private void descendingForEach(KTypePredicate<? super KType> predicate, int fromIndex, final int toIndex) {
    if (fromIndex == toIndex)
      return;

    final KType[] buffer = Intrinsics.<KType[]> cast(this.buffer);
    int i = toIndex;
    do {
      i = oneLeft(i, buffer.length);
      if (!predicate.apply(buffer[i])) {
        break;
      }
    } while (i != fromIndex);
  }
367688
private void applyVerticalLimit()
    {
        if (mover.getY() < limitBottom && limitBottom != Integer.MIN_VALUE)
        {
            mover.teleportY(limitBottom);
        }
        else if (mover.getY() > limitTop && limitTop != Integer.MAX_VALUE)
        {
            mover.teleportY(limitTop);
        }
    }
90033
@Override
	public void decrease(final int steps) throws IOException {

		if (currentValue == 0) {
			return;
		}
		if (steps < 0) {
			throw new RuntimeException("Only positive values for parameter 'steps' allowed!");
		}
		if (getNonVolatileMode() != MicrochipPotentiometerNonVolatileMode.VOLATILE_ONLY) {
			throw new RuntimeException("'decrease' is only valid for NonVolatileMode.VOLATILE_ONLY!");
		}

		// check boundaries
		final int actualSteps;
		if (steps > currentValue) {
			actualSteps = currentValue;
		} else {
			actualSteps = steps;
		}

		int newValue = currentValue - actualSteps;

		// if lower-boundary then set value in device to ensure sync
		// and for a large number of steps it is better to set a new value
		if ((newValue == 0)
				|| (steps > 5)) {

			setCurrentValue(newValue);

		}
		// for a small number of steps use 'decrease'-method
		else {

			controller.decrease(DeviceControllerChannel.valueOf(channel), actualSteps);

			currentValue = newValue;

		}

	}
277368
private static void stopAllocCounting() {
        Runtime.getRuntime().gc();
        Runtime.getRuntime().runFinalization();
        Runtime.getRuntime().gc();
        Debug.stopAllocCounting();
    }