Java Code Examples for java.util.concurrent.atomic.AtomicBoolean#compareAndSet()

protected boolean hasActiveReads(AllocationPoint point) {
    Queue<cudaEvent_t> events = point.getReadLane();

    if (events.size() == 0)
        return false;

    AtomicBoolean result = new AtomicBoolean(false);
    List<cudaEvent_t> asList = new ArrayList<>(events);
    for (cudaEvent_t event : asList) {
        if (event == null)
            continue;

        // we mark this AllocationPoint is pending read, if at least one event isn't destroyed yet
        result.compareAndSet(false, !event.isDestroyed());
    }

    return result.get();
}
 

public void tAtomicBoolean() {
    System.currentTimeMillis();
    AtomicBoolean atomic = new AtomicBoolean();

    long t1 = System.currentTimeMillis();
    for (int i = 0; i < 10000000; i++) {
        if (atomic.compareAndSet(false, true)) {
            try {
                // ...
            } finally {
                atomic.set(false);
            }
        }
    }
    long t2 = System.currentTimeMillis();

    System.out.println("take time:" + (t2 - t1) + " ms.");
}
 

public void tAtomicBoolean() {
    System.currentTimeMillis();
    AtomicBoolean atomic = new AtomicBoolean();

    long t1 = System.currentTimeMillis();
    for (int i = 0; i < 10000000; i++) {
        if (atomic.compareAndSet(false, true)) {
            try {
                // ...
            } finally {
                atomic.set(false);
            }
        }
    }
    long t2 = System.currentTimeMillis();

    System.out.println("take time:" + (t2 - t1) + " ms.");
}
 

/**
 * Adapts a Vert.x {@code Handler<AsyncResult<T>>} to an RxJava {@link Subscriber}.
 * <p>
 * The returned subscriber can be subscribed to an {@link Observable#subscribe(Subscriber)} or
 * {@link rx.Single#subscribe(Subscriber)}.
 *
 * @param handler the handler to adapt
 * @return the subscriber
 */
public static <T> Subscriber<T> toSubscriber(Handler<AsyncResult<T>> handler) {
  AtomicBoolean completed = new AtomicBoolean();
  return new Subscriber<T>() {
    @Override
    public void onCompleted() {
      if (completed.compareAndSet(false, true)) {
        handler.handle(Future.succeededFuture());
      }
    }
    @Override
    public void onError(Throwable error) {
      if (completed.compareAndSet(false, true)) {
        handler.handle(Future.failedFuture(error));
      }
    }
    @Override
    public void onNext(T item) {
      if (completed.compareAndSet(false, true)) {
        handler.handle(Future.succeededFuture(item));
      }
    }
  };
}
 

protected void init() {
    observables = new LinkedBlockingQueue<>(queueLimit);

    int numDevices = Nd4j.getAffinityManager().getNumberOfDevices();
    int currentDevice = Nd4j.getAffinityManager().getDeviceForCurrentThread();
    AtomicBoolean assignedRoot = new AtomicBoolean(false);

    zoo = new InferenceWorker[workers];
    for (int i = 0; i < workers; i++) {
        int cDevice = i % numDevices;
        boolean cRoot = !assignedRoot.get() && cDevice == currentDevice;
        assignedRoot.compareAndSet(false, cRoot);

        zoo[i] = new InferenceWorker(i, model, observables, cRoot, cDevice);

        zoo[i].setDaemon(true);
        zoo[i].start();
    }


    if (inferenceMode == InferenceMode.BATCHED) {
        log.info("Initializing ObservablesProvider...");
        provider = new ObservablesProvider(nanos, batchLimit, observables);
    }
}
 

/**
 * Adapts an Vert.x {@code Handler<AsyncResult<T>>} to an RxJava2 {@link SingleObserver}.
 * <p>
 * The returned observer can be subscribed to an {@link Single#subscribe(SingleObserver)}.
 *
 * @param handler the handler to adapt
 * @return the observer
 */
public static <T> CompletableObserver toObserver(Handler<AsyncResult<T>> handler) {
  AtomicBoolean completed = new AtomicBoolean();
  return new CompletableObserver() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {
    }
    @Override
    public void onComplete() {
      if (completed.compareAndSet(false, true)) {
        handler.handle(io.vertx.core.Future.succeededFuture());
      }
    }
    public void onSuccess() {
      if (completed.compareAndSet(false, true)) {
        handler.handle(io.vertx.core.Future.succeededFuture());
      }
    }
    @Override
    public void onError(Throwable error) {
      if (completed.compareAndSet(false, true)) {
        handler.handle(io.vertx.core.Future.failedFuture(error));
      }
    }
  };
}
 

/**
 * compareAndSet in one thread enables another waiting for value
 * to succeed
 */
public void testCompareAndSetInMultipleThreads() throws Exception {
    final AtomicBoolean ai = new AtomicBoolean(true);
    Thread t = new Thread(new CheckedRunnable() {
        public void realRun() {
            while (!ai.compareAndSet(false, true)) Thread.yield();
        }});

    t.start();
    assertTrue(ai.compareAndSet(true, false));
    t.join(LONG_DELAY_MS);
    assertFalse(t.isAlive());
}
 

/**
 * Wrap a given MessageCallback by a executor so that calls are executed in the given executor.
 * By running the calls through the executor, it also block and wait for the task being completed so that
 * it can block the poller thread depending on the rate of processing that the callback can handle.
 */
private MessageCallback wrapCallback(final MessageCallback callback,
                                     final ExecutorService executor, final Cancellable cancellable) {
  final AtomicBoolean stopped = new AtomicBoolean();
  return new MessageCallback() {
    @Override
    public long onReceived(final Iterator<FetchedMessage> messages) {
      if (stopped.get()) {
        return -1L;
      }
      return Futures.getUnchecked(executor.submit(new Callable<Long>() {
        @Override
        public Long call() {
          if (stopped.get()) {
            return -1L;
          }
          return callback.onReceived(messages);
        }
      }));
    }

    @Override
    public void finished() {
      // Make sure finished only get called once.
      if (!stopped.compareAndSet(false, true)) {
        return;
      }
      Futures.getUnchecked(executor.submit(new Runnable() {
        @Override
        public void run() {
          // When finished is called, also cancel the consumption from all polling thread.
          callback.finished();
          cancellable.cancel();
        }
      }));
    }
  };
}
 

private void item_unlink_q(long addr) {
	int clsid = ItemUtil.getSlabsClsid(addr);
	AtomicBoolean lru_locks = JcacheContext.getLRU_Lock(clsid);
	while(!lru_locks.compareAndSet(false, true)){}
	try {
		do_item_unlink_q(addr);
	} finally {
		lru_locks.lazySet(false);
	}
}
 

/**
 * Reloads the dictionary. Access is controlled on a per dictionary file basis.
 */
private void asyncReloadDictionary() {
    final AtomicBoolean isReloading = mIsReloading;
    if (!isReloading.compareAndSet(false, true)) {
        return;
    }
    final File dictFile = mDictFile;
    asyncExecuteTaskWithWriteLock(new Runnable() {
        @Override
        public void run() {
            try {
                if (!dictFile.exists() || isNeededToRecreate()) {
                    // If the dictionary file does not exist or contents have been updated,
                    // generate a new one.
                    createNewDictionaryLocked();
                } else if (getBinaryDictionary() == null) {
                    // Otherwise, load the existing dictionary.
                    loadBinaryDictionaryLocked();
                    final BinaryDictionary binaryDictionary = getBinaryDictionary();
                    if (binaryDictionary != null && !(isValidDictionaryLocked()
                            // TODO: remove the check below
                            && matchesExpectedBinaryDictFormatVersionForThisType(
                                    binaryDictionary.getFormatVersion()))) {
                        // Binary dictionary or its format version is not valid. Regenerate
                        // the dictionary file. createNewDictionaryLocked will remove the
                        // existing files if appropriate.
                        createNewDictionaryLocked();
                    }
                }
                clearNeedsToRecreate();
            } finally {
                isReloading.set(false);
            }
        }
    });
}
 

@Test
public void testPopularityWalker4() throws Exception {
    GraphWalker<VocabWord> walker =
                    new PopularityWalker.Builder<>(graph).setWalkDirection(WalkDirection.FORWARD_ONLY)
                                    .setNoEdgeHandling(NoEdgeHandling.CUTOFF_ON_DISCONNECTED).setWalkLength(10)
                                    .setPopularityMode(PopularityMode.MINIMUM).setPopularitySpread(3)
                                    .setSpreadSpectrum(SpreadSpectrum.PROPORTIONAL).build();

    System.out.println("Connected [3] size: " + graph.getConnectedVertices(3).size());
    System.out.println("Connected [4] size: " + graph.getConnectedVertices(4).size());

    AtomicBoolean got3 = new AtomicBoolean(false);
    AtomicBoolean got8 = new AtomicBoolean(false);
    AtomicBoolean got9 = new AtomicBoolean(false);

    for (int i = 0; i < 50; i++) {
        Sequence<VocabWord> sequence = walker.next();
        assertEquals("0", sequence.getElements().get(0).getLabel());
        System.out.println("Position at 1: [" + sequence.getElements().get(1).getLabel() + "]");

        got3.compareAndSet(false, sequence.getElements().get(1).getLabel().equals("3"));
        got8.compareAndSet(false, sequence.getElements().get(1).getLabel().equals("8"));
        got9.compareAndSet(false, sequence.getElements().get(1).getLabel().equals("9"));

        assertTrue(sequence.getElements().get(1).getLabel().equals("8")
                        || sequence.getElements().get(1).getLabel().equals("3")
                        || sequence.getElements().get(1).getLabel().equals("9"));

        walker.reset(false);
    }

    assertTrue(got3.get());
    assertTrue(got8.get());
    assertTrue(got9.get());
}
 

protected void chooseAttackersRace() {
	AtomicBoolean next = new AtomicBoolean(Math.random() < 0.5);
	for (Race race : list) {
		if (race == null) {
			throw new NullPointerException("Base:" + race + " race is null chooseAttackersRace!");
		}
		else if (!race.equals(getRace())) {
			if (next.compareAndSet(true, false)) {
				continue;
			}
			spawnAttackers(race);
		}
	}
}
 

@Override
public void addFinalTaskInfoListener(StateChangeListener<TaskInfo> stateChangeListener)
{
    AtomicBoolean done = new AtomicBoolean();
    StateChangeListener<TaskState> fireOnceStateChangeListener = state -> {
        if (state.isDone() && done.compareAndSet(false, true)) {
            stateChangeListener.stateChanged(getTaskInfo());
        }
    };
    taskStateMachine.addStateChangeListener(fireOnceStateChangeListener);
    fireOnceStateChangeListener.stateChanged(taskStateMachine.getState());
}
 

/**
 * Add a listener for the final task info.  This notification is guaranteed to be fired only once.
 * Listener is always notified asynchronously using a dedicated notification thread pool so, care should
 * be taken to avoid leaking {@code this} when adding a listener in a constructor. Additionally, it is
 * possible notifications are observed out of order due to the asynchronous execution.
 */
public void addFinalTaskInfoListener(StateChangeListener<TaskInfo> stateChangeListener)
{
    AtomicBoolean done = new AtomicBoolean();
    StateChangeListener<Optional<TaskInfo>> fireOnceStateChangeListener = finalTaskInfo -> {
        if (finalTaskInfo.isPresent() && done.compareAndSet(false, true)) {
            stateChangeListener.stateChanged(finalTaskInfo.get());
        }
    };
    finalTaskInfo.addStateChangeListener(fireOnceStateChangeListener);
    fireOnceStateChangeListener.stateChanged(finalTaskInfo.get());
}
 

public static void toggleRuntimeState(AtomicBoolean state) {
    boolean runtimeVal = false;
    while (!state.compareAndSet(runtimeVal, !runtimeVal)) {
        runtimeVal = !runtimeVal;
    }
}
 

private void handleComplete(AtomicBoolean completeSent,Runnable onComplete){
    if(completeSent.compareAndSet(false,true)){
        onComplete.run();
    }
}
 

@Override
public void subscribeActual(final CompletableObserver s) {
    CompletableSource[] sources = this.sources;
    int count = 0;
    if (sources == null) {
        sources = new CompletableSource[8];
        try {
            for (CompletableSource element : sourcesIterable) {
                if (element == null) {
                    EmptyDisposable.error(new NullPointerException("One of the sources is null"), s);
                    return;
                }
                if (count == sources.length) {
                    CompletableSource[] b = new CompletableSource[count + (count >> 2)];
                    System.arraycopy(sources, 0, b, 0, count);
                    sources = b;
                }
                sources[count++] = element;
            }
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            EmptyDisposable.error(e, s);
            return;
        }
    } else {
        count = sources.length;
    }

    final CompositeDisposable set = new CompositeDisposable();
    s.onSubscribe(set);

    final AtomicBoolean once = new AtomicBoolean();

    CompletableObserver inner = new Amb(once, set, s);

    for (int i = 0; i < count; i++) {
        CompletableSource c = sources[i];
        if (set.isDisposed()) {
            return;
        }
        if (c == null) {
            NullPointerException npe = new NullPointerException("One of the sources is null");
            if (once.compareAndSet(false, true)) {
                set.dispose();
                s.onError(npe);
            } else {
                RxJavaCommonPlugins.onError(npe);
            }
            return;
        }

        // no need to have separate observers because inner is stateless
        c.subscribe(inner);
    }

    if (count == 0) {
        s.onComplete();
    }
}
 

@Override
public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
    MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions, Channel channel) {
  ClientCall<ReqT, RespT> newCall = channel.newCall(methodDescriptor, callOptions);
  final AtomicBoolean countedCancel = new AtomicBoolean(false);

  // A streaming call might be terminated in one of several possible ways:
  // * The call completes normally -> onClose() will be invoked.
  // * The context is cancelled -> CancellationListener.cancelled() will be called.
  // * The call itself is cancelled (doesn't currently happen) -> ClientCall.cancel() called.
  //
  // It's possible more than one of these could happen, so we use countedCancel to make sure we
  // don't double count a decrement.
  Context.current()
      .addListener(
          context -> {
            if (countedCancel.compareAndSet(false, true)) {
              ongoingRequestCount.decrementAndGet();
            }
          },
          backgroundTasksThreadPool);

  return new SimpleForwardingClientCall(newCall) {
    @Override
    public void cancel(@Nullable String message, @Nullable Throwable cause) {
      if (countedCancel.compareAndSet(false, true)) {
        ongoingRequestCount.decrementAndGet();
      }
      super.cancel(message, cause);
    }

    @Override
    public void start(Listener responseListener, Metadata headers) {
      ongoingRequestCount.incrementAndGet();
      this.delegate()
          .start(
              new SimpleForwardingClientCallListener(responseListener) {
                @Override
                public void onClose(Status status, Metadata trailers) {
                  if (countedCancel.compareAndSet(false, true)) {
                    ongoingRequestCount.decrementAndGet();
                  }
                  super.onClose(status, trailers);
                }
              },
              headers);
    }
  };
}
 

private void handleComplete(AtomicBoolean completeSent,Runnable onComplete){
    if(completeSent.compareAndSet(false,true)){
        onComplete.run();
    }
}
 

@Test
public void testOfferPollSemantics() throws Exception
{
    final AtomicBoolean stop = new AtomicBoolean();
    final AtomicBoolean consumerLock = new AtomicBoolean(true);
    final Queue<Integer> q = new MpscArrayQueue<Integer>(2);
    // fill up the queue
    while (q.offer(1))
    {
        ;
    }
    // queue has 2 empty slots
    q.poll();
    q.poll();

    final Val fail = new Val();
    final Runnable runnable = new Runnable()
    {
        @Override
        public void run()
        {
            while (!stop.get())
            {
                if (!q.offer(1))
                {
                    fail.value++;
                }

                while (!consumerLock.compareAndSet(true, false))
                {
                    ;
                }
                if (q.poll() == null)
                {
                    fail.value++;
                }
                consumerLock.lazySet(true);
            }
        }
    };
    Thread t1 = new Thread(runnable);
    Thread t2 = new Thread(runnable);

    t1.start();
    t2.start();
    Thread.sleep(1000);
    stop.set(true);
    t1.join();
    t2.join();
    assertEquals("Unexpected offer/poll observed", 0, fail.value);
}