/** getAndAdd returns previous value and adds given value */ public void testGetAndAdd() { AtomicInteger ai = new AtomicInteger(1); assertEquals(1, ai.getAndAdd(2)); assertEquals(3, ai.get()); assertEquals(3, ai.getAndAdd(-4)); assertEquals(-1, ai.get()); }
void foo() { i.getAndAdd(2); i.getAndAdd(-5); if (i.get() == 0) { i.set(9); } System.out.println(i.addAndGet(9)); System.out.println(i.addAndGet(-(9))); }
@Override public void ping(PingInfo pingInfo, Promise<PingResultInfo> promise) { int pingId = pingIds.getAndAdd(2); PingInfoCallback pingInfoCallback = new PingInfoCallback(pingId, promise); PingFrame frame = new PingFrame(version, pingId); control(null, frame, pingInfo.getTimeout(), pingInfo.getUnit(), pingInfoCallback); }
/** Notifies all waiting threads */ private final void atomicNotify() { if (waiting.getAndAdd(0) > 0) { synchronized (this) { notifyAll(); } } }
public Thread newThread(final Runnable r) { final Thread t = new Thread(r); t.setName("Golden-Sample: " + getClass().getName() + "-" + threadNumber.getAndAdd(1)); t.setDaemon(true); t.setPriority(3); return t; }
@Override public void newStream(HeadersFrame frame, Promise<Stream> promise, Stream.Listener listener) { // Synchronization is necessary to atomically create // the stream id and enqueue the frame to be sent. boolean queued; synchronized (this) { int streamId = frame.getStreamId(); if (streamId <= 0) { streamId = streamIds.getAndAdd(2); PriorityFrame priority = frame.getPriority(); priority = priority == null ? null : new PriorityFrame( streamId, priority.getParentStreamId(), priority.getWeight(), priority.isExclusive()); frame = new HeadersFrame(streamId, frame.getMetaData(), priority, frame.isEndStream()); } final IStream stream = createLocalStream(streamId, promise); if (stream == null) return; stream.setListener(listener); ControlEntry entry = new ControlEntry(frame, stream, new PromiseCallback<>(promise, stream)); queued = flusher.append(entry); } // Iterate outside the synchronized block. if (queued) flusher.iterate(); }
@Override public void syn(SynInfo synInfo, StreamFrameListener listener, Promise<Stream> promise) { // Synchronization is necessary. // SPEC v3, 2.3.1 requires that the stream creation be monotonically crescent // so we cannot allow thread1 to create stream1 and thread2 create stream3 and // have stream3 hit the network before stream1, not only to comply with the spec // but also because the compression context for the headers would be wrong, as the // frame with a compression history will come before the first compressed frame. int associatedStreamId = 0; if (synInfo instanceof PushSynInfo) associatedStreamId = ((PushSynInfo) synInfo).getAssociatedStreamId(); synchronized (this) { int streamId = streamIds.getAndAdd(2); // TODO: for SPDYv3 we need to support the "slot" argument SynStreamFrame synStream = new SynStreamFrame( version, synInfo.getFlags(), streamId, associatedStreamId, synInfo.getPriority(), (short) 0, synInfo.getHeaders()); IStream stream = createStream(synStream, listener, true, promise); if (stream == null) return; generateAndEnqueueControlFrame( stream, synStream, synInfo.getTimeout(), synInfo.getUnit(), stream); } flush(); }
private void whatOption() { what.incrementAndGet(); if (what.get() > mVpList.size() - 1) { what.getAndAdd(-mVpList.size()); } try { Thread.sleep(5000); } catch (InterruptedException e) { } }
private void whatOptionMall() { whatMall.incrementAndGet(); if (whatMall.get() > imageViewsMall.length - 1) { whatMall.getAndAdd(-4); } try { Thread.sleep(2500); } catch (InterruptedException e) { } }
// returns old value private int incVisitorUsageCount(int delta) { AtomicInteger count = myProject.getUserData(HIGHLIGHT_VISITOR_INSTANCE_COUNT); if (count == null) { count = ((UserDataHolderEx) myProject) .putUserDataIfAbsent(HIGHLIGHT_VISITOR_INSTANCE_COUNT, new AtomicInteger(0)); } int old = count.getAndAdd(delta); assert old + delta >= 0 : old + ";" + delta; return old; }
@Override public void onFailure(Throwable t) { flumeFailureLogCount.getAndAdd(size); LOG.warn("Failed to store record", t); if (t instanceof IOException) { callback.onConnectionError(); } else if (t instanceof EventDeliveryException) { callback.onRemoteError(); } else { callback.onInternalError(); } }
private void whatOpition() { what.incrementAndGet(); if (what.get() > dotImageViews.length - 1) { what.getAndAdd(-3); } try { Thread.sleep(8000); } catch (InterruptedException e) { e.printStackTrace(); } }
@Override public int priority(PriorityFrame frame, Callback callback) { int streamId = frame.getStreamId(); IStream stream = streams.get(streamId); if (stream == null) { streamId = streamIds.getAndAdd(2); frame = new PriorityFrame( streamId, frame.getParentStreamId(), frame.getWeight(), frame.isExclusive()); } control(stream, callback, frame); return streamId; }
/** consume returns a CompletableFuture that is done when publisher completes */ public void testConsume() { AtomicInteger sum = new AtomicInteger(); SubmissionPublisher<Integer> p = basicPublisher(); CompletableFuture<Void> f = p.consume( (Integer x) -> { sum.getAndAdd(x.intValue()); }); int n = 20; for (int i = 1; i <= n; ++i) p.submit(i); p.close(); f.join(); assertEquals((n * (n + 1)) / 2, sum.get()); }
@Override public void clear() { for (int i = 0; i < size(); i++) { // It is likely that we have at most one violation pass this check each time around. if (Math.random() < UPLOAD_PROBABILITY) { // Ensure that we do not upload too many StrictMode violations in any single // session. To prevent races, we allow sNumUploads to increase beyond the // limit, but just skip actually uploading the stack trace then. if (sNumUploads.getAndAdd(1) >= MAX_UPLOADS_PER_SESSION) { break; } sCachedStackTraces.add(get(i)); } } super.clear(); }
@Override public void push( IStream stream, Promise<Stream> promise, PushPromiseFrame frame, Stream.Listener listener) { // Synchronization is necessary to atomically create // the stream id and enqueue the frame to be sent. boolean queued; synchronized (this) { int streamId = streamIds.getAndAdd(2); frame = new PushPromiseFrame(frame.getStreamId(), streamId, frame.getMetaData()); final IStream pushStream = createLocalStream(streamId, promise); if (pushStream == null) return; pushStream.setListener(listener); ControlEntry entry = new ControlEntry(frame, pushStream, new PromiseCallback<>(promise, pushStream)); queued = flusher.append(entry); } // Iterate outside the synchronized block. if (queued) flusher.iterate(); }
public void receiveCredits(final int credits) throws Exception { if (credits == -1) { if (HornetQServerLogger.LOGGER.isDebugEnabled()) { HornetQServerLogger.LOGGER.debug( this + ":: FlowControl::Received disable flow control message"); } // No flow control availableCredits = null; // There may be messages already in the queue promptDelivery(); } else if (credits == 0) { // reset, used on slow consumers HornetQServerLogger.LOGGER.debug( this + ":: FlowControl::Received reset flow control message"); availableCredits.set(0); } else { int previous = availableCredits.getAndAdd(credits); if (HornetQServerLogger.LOGGER.isDebugEnabled()) { HornetQServerLogger.LOGGER.debug( this + "::FlowControl::Received " + credits + " credits, previous value = " + previous + " currentValue = " + availableCredits.get()); } if (previous <= 0 && previous + credits > 0) { if (HornetQServerLogger.LOGGER.isTraceEnabled()) { HornetQServerLogger.LOGGER.trace( this + "::calling promptDelivery from receiving credits"); } promptDelivery(); } } }
@Override public int updateSendWindow(int delta) { return sendWindow.getAndAdd(delta); }
/** Sets an artificial document from which term vectors are requested for. */ public TermVectorRequest doc(XContentBuilder documentBuilder) { // assign a random id to this artificial document, for routing this.id(String.valueOf(randomInt.getAndAdd(1))); this.doc = documentBuilder.bytes(); return this; }
/** * Add the given value to this reduction variable and return the previous value. * * @param value Value to add. * @return Previous value. */ public int getAndAdd(int value) { return myValue.getAndAdd(value); }
public Tuple map(Object... args) { return PrototypedTuple.singleton(count.getAndAdd(1)); }
public void run(int gid) { outArray[gid] = atomicInt.getAndAdd(0x7); }
@Override public int updateRecvWindow(int delta) { return recvWindow.getAndAdd(delta); }
public int generate() { return idGenerator.getAndAdd(gap); }
/** 1. 将AtomicInteger中维护的int值加上一个给定的值, 并且返回原来的int值 */ public void testGetAndAdd() { AtomicInteger ai = new AtomicInteger(9); System.out.println(ai.getAndAdd(10)); // 9 }
@Override public void onSuccess(AppendBatchAsyncResultPojo result) { flumeSuccessLogCount.getAndAdd(size); callback.onSuccess(); }
public PrimitiveBench(String[] args) { int runs = 100000000; int cur = 0; if (args.length != 1) { System.out.println("usage: java " + getClass().getSimpleName() + " CASE_NUMBER"); System.out.println("\twhere CASE_NUMBER is in {1,2,..,5}"); System.exit(-1); } int caseno = Integer.parseInt(args[0]); boolean result1 = false, result2 = false; switch (caseno) { // case 1: break; // case 2: break; // case 3: break; case 4: { System.out.println("fetch and add"); AtomicInteger addr = new AtomicInteger(0); for (int i = 0; i < runs; i++) { cur = addr.getAndAdd(1); cur = addr.getAndAdd(-1); } if (cur != 1) throw new RuntimeException("cur = " + cur); if (addr.get() != 0) throw new RuntimeException("addr.get() = " + addr.get()); } break; case 5: { System.out.println("compare and swap"); AtomicInteger addr = new AtomicInteger(0); for (int i = 0; i < runs; i++) { result1 = addr.compareAndSet(cur, cur + 1); result2 = addr.compareAndSet(cur + 1, cur); } if (!result1 || !result2) throw new RuntimeException("result1 = " + result1 + " result2 = " + result2); if (addr.get() != 0) throw new RuntimeException("addr.get() = " + addr.get()); } break; case 6: { System.out.println("atomic updater cas"); IntHolder addr = new IntHolder(0); AtomicIntegerFieldUpdater<IntHolder> updater = AtomicIntegerFieldUpdater.newUpdater(IntHolder.class, "v"); for (int i = 0; i < runs; i++) { result1 = updater.compareAndSet(addr, cur, cur + 1); result2 = updater.compareAndSet(addr, cur + 1, cur); } if (!result1 || !result2) throw new RuntimeException("result1 = " + result1 + " result2 = " + result2); if (addr.v != 0) throw new RuntimeException("addr.v = " + addr.v); } break; default: { System.out.println("bad case number specified: " + caseno); } break; } }
@Override protected Integer initialValue() { return uniqueAddr.getAndAdd(TCP_PORT_RANGE_PER_THREAD); }
private void addBuildFilesToProcess(Set<Path> buildFiles) { Preconditions.checkArgument(buildFiles.size() > 0); Preconditions.checkState(pendingBuildTargets.size() == 0); pendingWorkQueueCount.getAndAdd(buildFiles.size()); Preconditions.checkState(pendingBuildFiles.addAll(buildFiles)); }
/** Constructor. */ @SuppressWarnings("deprecation") protected ProcessStarter() { iProcessListener = new LinkedList<ProcessListener>(); iProcessEventListener = new LinkedList<ProcessEventListener>(); iPID = iPIDCounter.getAndAdd(1); }