Java AtomicInteger.decrementAndGet方法代码示例

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
public void connect(final String webSocketServerUrl, final JSExecutorConnectCallback callback) {
  final AtomicInteger retryCount = new AtomicInteger(CONNECT_RETRY_COUNT);
  final JSExecutorConnectCallback retryProxyCallback = new JSExecutorConnectCallback() {
    @Override
    public void onSuccess() {
      callback.onSuccess();
    }

    @Override
    public void onFailure(Throwable cause) {
      if (retryCount.decrementAndGet() <= 0) {
        callback.onFailure(cause);
      } else {
        connectInternal(webSocketServerUrl, this);
      }
    }
  };
  connectInternal(webSocketServerUrl, retryProxyCallback);
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
@Test
public void disposeRace() {
    ExecutorService exec = Executors.newSingleThreadExecutor();
    final Scheduler s = Schedulers.from(exec);
    try {
        for (int i = 0; i < 500; i++) {
            final Worker w = s.createWorker();

            final AtomicInteger c = new AtomicInteger(2);

            w.schedule(new Runnable() {
                @Override
                public void run() {
                    c.decrementAndGet();
                    while (c.get() != 0) { }
                }
            });

            c.decrementAndGet();
            while (c.get() != 0) { }
            w.dispose();
        }
    } finally {
        exec.shutdownNow();
    }
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
@Test
public void testSubmitTrue() throws IOException {
  final AsyncProcess ap = new MyAsyncProcess(createHConnection(), conf, false);
  ap.tasksInProgress.incrementAndGet();
  final AtomicInteger ai = new AtomicInteger(1);
  ap.taskCounterPerRegion.put(hri1.getRegionName(), ai);

  final AtomicBoolean checkPoint = new AtomicBoolean(false);
  final AtomicBoolean checkPoint2 = new AtomicBoolean(false);

  Thread t = new Thread(){
    @Override
    public void run(){
      Threads.sleep(1000);
      Assert.assertFalse(checkPoint.get()); // TODO: this is timing-dependent
      ai.decrementAndGet();
      ap.tasksInProgress.decrementAndGet();
      checkPoint2.set(true);
    }
  };

  List<Put> puts = new ArrayList<Put>();
  Put p = createPut(1, true);
  puts.add(p);

  ap.submit(DUMMY_TABLE, puts, false, null, false);
  Assert.assertFalse(puts.isEmpty());

  t.start();

  ap.submit(DUMMY_TABLE, puts, true, null, false);
  Assert.assertTrue(puts.isEmpty());

  checkPoint.set(true);
  while (!checkPoint2.get()){
    Threads.sleep(1);
  }
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
private Session findFreeSession() {
    for (Entry<Session, AtomicInteger> entry : sessions.entrySet()) {
        Session s = entry.getKey();
        AtomicInteger availableChannels = entry.getValue();
        if (s.isConnected() && availableChannels.get() > 0) {
            log.log(Level.FINE, "availableChannels == {0}", new Object[]{availableChannels.get()}); // NOI18N
            int remains = availableChannels.decrementAndGet();
            log.log(Level.FINE, "Reuse session [{0}]. {1} channels remain...", new Object[]{System.identityHashCode(s), remains}); // NOI18N
            return s;
        }
    }

    return null;
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
public void testScheduleFixedRateOnMultiThreadPoolDoesNotCauseConcurrentExecution() throws Exception {
    final AtomicInteger val = new AtomicInteger(0);
    final CountDownLatch latch = new CountDownLatch(10);
    class C implements Runnable {
        boolean failed;
        @Override
        public void run() {
            try {
                int now = val.incrementAndGet();
                if (now > 1) {
                    failed = true;
                    fail (now + " threads simultaneously in run()");
                }
                try {
                    //Intentionally sleep *longer* than the interval
                    //between executions.  We *want* to pile up all of the
                    //RP threads entering run() - synchronization should
                    //serialize them.  This test is to prove that this
                    //method will never be called concurrently from two threads
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {

                }
            } finally {
                val.decrementAndGet();
                latch.countDown();
            }
        }
    }
    C c = new C();
    long initialDelay = 2000;
    long period = 10;
    RequestProcessor rp = new RequestProcessor("testScheduleFixedRateOnMultiThreadPoolDoesNotCauseConcurrentExecution", 10, true);
    rp.scheduleAtFixedRate(c, initialDelay, period, TimeUnit.MILLISECONDS);
    latch.await();
    assertFalse(c.failed);
    rp.stop();
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
public void start() {
    if (scrollId.getContext().length == 0) {
        listener.onFailure(new SearchPhaseExecutionException("query", "no nodes to search on", ShardSearchFailure.EMPTY_ARRAY));
        return;
    }
    final AtomicInteger counter = new AtomicInteger(scrollId.getContext().length);

    ScrollIdForNode[] context = scrollId.getContext();
    for (int i = 0; i < context.length; i++) {
        ScrollIdForNode target = context[i];
        DiscoveryNode node = nodes.get(target.getNode());
        if (node != null) {
            executeQueryPhase(i, counter, node, target.getScrollId());
        } else {
            if (logger.isDebugEnabled()) {
                logger.debug("Node [" + target.getNode() + "] not available for scroll request [" + scrollId.getSource() + "]");
            }
            successfulOps.decrementAndGet();
            if (counter.decrementAndGet() == 0) {
                try {
                    executeFetchPhase();
                } catch (Throwable e) {
                    listener.onFailure(new SearchPhaseExecutionException("query", "Fetch failed", e, ShardSearchFailure.EMPTY_ARRAY));
                    return;
                }
            }
        }
    }
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
@Override
protected void decrementFileID(int fileID) {
  AtomicInteger counter = logFileIDReferenceCounts.get(fileID);
  Preconditions.checkState(counter != null, "null counter ");
  int count = counter.decrementAndGet();
  if (count == 0) {
    logFileIDReferenceCounts.remove(fileID);
  }
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
private static void removeFromReplica(
    Map<Integer, AtomicInteger> replica, int value) {
  AtomicInteger numOccur = replica.get(value);
  if (numOccur.decrementAndGet() == 0) {
    replica.remove(value);
  }
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
/**
 * 加载本地
 *
 * @param count
 * @param callback
 * @param result
 */
private static void callCallback(final AtomicInteger count, final LoadCallback callback, final Map<String, Drawable> result) {
    synchronized (count) {
        if (count.decrementAndGet() <= 0) {//全部下载完毕的时候回调
            if (callback != null) {
                callback.onLoadResult(result);
            }
        }
    }
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
/**
 * Unrefer void.
 */
public synchronized void unrefer() {
    if (proxyIns == null) {
        return;
    }
    String key = buildKey();
    LOGGER.info("Unrefer consumer config : {} with bean id {}", key, getId());
    try {
        client.destroy();
    } catch (Exception e) {
        LOGGER.warn("Catch exception when unrefer consumer config : " + key
                + ", but you can ignore if it's called by JVM shutdown hook", e);
    }
    // 清除一些缓存
    AtomicInteger cnt = REFERRED_KEYS.get(key);
    if (cnt != null && cnt.decrementAndGet() <= 0) {
        REFERRED_KEYS.remove(key);
    }
    configListener = null;
    providerListener = null;
    JSFContext.invalidateConsumerConfig(this);
    RpcStatus.removeStatus(this);
    proxyIns = null;

    // 取消订阅到注册中心
    unsubscribe();
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
private void decrementOpenConnections(VirtualObject virtualObject) throws DatabaseException {
	AtomicInteger openConnectionCounter = getOpenConnectionCounter(virtualObject.getOid());
	int decrementAndGet = openConnectionCounter.decrementAndGet();
	if (decrementAndGet == 0) {
		deserializer.addVirtualObjectToSave(virtualObject);
	} else if (decrementAndGet < 0) {
		throw new DatabaseException("Inconsistent state");
	}
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
public static void main(String[] args) throws InterruptedException, ExecutionException {
    ExecutorService executorService = Executors.newFixedThreadPool(THREADS_NUMBER);

    CallCounter counter = new CallCounterReadWriteLock();
    AtomicInteger realCountNumber = new AtomicInteger();

    Callable<Integer> callable = () -> {
        while (realCountNumber.getAndIncrement() < HUNDRED_MILLION) {
            counter.increment();
        }
        realCountNumber.decrementAndGet();
        return counter.getCount();
    };

    long startTime = System.currentTimeMillis();


    Future<Integer> future01 = executorService.submit(callable);
    Future<Integer> future02 = executorService.submit(callable);

    System.out.println("Future01: " + future01.get());
    System.out.println("Future02: " + future02.get());
    System.out.println("RealCountNumber: " + realCountNumber);

    long finishTime = System.currentTimeMillis();
    System.out.println("Time spent: " + (finishTime - startTime));
    executorService.shutdown();
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
public synchronized void unregisterConnection(ConnectContext ctx) {
    if (connectionMap.remove((long) ctx.getConnectionId()) != null) {
        numberConnection--;
        AtomicInteger conns = connByUser.get(ctx.getUser());
        if (conns != null) {
            conns.decrementAndGet();
        }
    }
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
@Test
public void emissionRequestRace() {
    Worker w = Schedulers.computation().createWorker();
    try {
        for (int i = 0; i < 10000; i++) {

            final TestSubscriber<Integer> ts = TestSubscriber.create(0L);
            TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts);
            ds.setupDownstream();
            ds.onNext(1);

            final AtomicInteger ready = new AtomicInteger(2);

            w.schedule(new Runnable() {
                @Override
                public void run() {
                    ready.decrementAndGet();
                    while (ready.get() != 0) { }

                    ts.request(1);
                }
            });

            ready.decrementAndGet();
            while (ready.get() != 0) { }

            ds.onComplete();

            ts.awaitTerminalEvent(5, TimeUnit.SECONDS);
            ts.assertValues(1);
            ts.assertNoErrors();
            ts.assertComplete();

        }
    } finally {
        w.dispose();
    }
}
 

import java.util.concurrent.atomic.AtomicInteger; //导入方法依赖的package包/类
private String tryGetCid(Set<String> blackSet) {
    AtomicInteger load;
    String cid = null;
    String tmpCid;
    int times = pieceContainer.size();
    boolean needOffer;
    while (times-- > 0) {
        needOffer = true;
        tmpCid = pieceContainer.peek();

        if (tmpCid == null) {
            pieceHitLogger.info("peek element from empty queue");
            break;
        }
        if (progressRepo.getServiceDownInfo(tmpCid)) {
            needOffer = false;
        } else {
            AtomicInteger errorCount = progressRepo
                .getServiceErrorInfo(tmpCid);
            if (errorCount != null
                && errorCount.get() >= Constants.ELIMINATION_LIMIT) {
                needOffer = false;
            } else {
                if (blackSet == null || !blackSet.contains(tmpCid)) {
                    load = progressRepo.getProducerLoad(tmpCid);
                    if (load != null) {
                        if (load.incrementAndGet() <= Constants.PEER_UP_LIMIT) {
                            cid = tmpCid;
                            break;
                        } else {
                            load.decrementAndGet();
                        }
                    } else {
                        needOffer = false;
                    }
                }
            }
        }
        synchronized (pieceContainer) {
            if (StringUtils.equals(pieceContainer.peek(), tmpCid)) {
                if (pieceContainer.remove(tmpCid) && needOffer) {
                    pieceContainer.offer(tmpCid);
                }
            }
        }

    }

    return cid;
}