Java AtomicReference.compareAndSet方法代码示例

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public final void compute() {
	final Fun<? super K, ? extends U> searchFunction;
	final AtomicReference<U> result;
	if ((searchFunction = this.searchFunction) != null && (result = this.result) != null) {
		for (int i = baseIndex, f, h; batch > 0 && (h = ((f = baseLimit) + i) >>> 1) > i;) {
			if (result.get() != null)
				return;
			addToPendingCount(1);
			new SearchKeysTask<K, V, U>(this, batch >>>= 1, baseLimit = h, f, tab, searchFunction, result)
					.fork();
		}
		while (result.get() == null) {
			U u;
			Node<K, V> p;
			if ((p = advance()) == null) {
				propagateCompletion();
				break;
			}
			if ((u = searchFunction.apply(p.key)) != null) {
				if (result.compareAndSet(null, u))
					quietlyCompleteRoot();
				break;
			}
		}
	}
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public void decFloat(String attributeName, Float oldVal) {
  if (oldVal == 0) {
    return;
  }
  AtomicReference<Number> ar = aggregateMap.get(attributeName);
  Number curVal;
  for (;;) {
    Number expectedVal = ar.get();
    if (expectedVal.floatValue() != 0) {
      curVal = expectedVal.floatValue() - oldVal;
    } else {
      return;
    }
    if (ar.compareAndSet(expectedVal, curVal)) {
      return;
    }
  }
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public void decLong(String attributeName, Long oldVal) {
  if (oldVal == 0) {
    return;
  }
  AtomicReference<Number> ar = aggregateMap.get(attributeName);
  Number curVal;
  for (;;) {
    Number expectedVal = ar.get();
    if (expectedVal.longValue() != 0) {
      curVal = expectedVal.longValue() - oldVal;
    } else {
      return;
    }
    if (ar.compareAndSet(expectedVal, curVal)) {
      return;
    }
  }
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public static <T> ConnectableObservable<T> create(Observable<? extends T> source) {
    final AtomicReference<PublishSubscriber<T>> curr = new AtomicReference();
    return new OperatorPublish(new Observable$OnSubscribe<T>() {
        public void call(Subscriber<? super T> child) {
            while (true) {
                PublishSubscriber<T> r = (PublishSubscriber) curr.get();
                if (r == null || r.isUnsubscribed()) {
                    PublishSubscriber<T> u = new PublishSubscriber(curr);
                    u.init();
                    if (curr.compareAndSet(r, u)) {
                        r = u;
                    } else {
                        continue;
                    }
                }
                InnerProducer<T> inner = new InnerProducer(r, child);
                if (r.add(inner)) {
                    child.add(inner);
                    child.setProducer(inner);
                    return;
                }
            }
        }
    }, source, curr);
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
private void addTask(final CraftTask task) {
    final AtomicReference<CraftTask> tail = this.tail;
    CraftTask tailTask = tail.get();
    while (!tail.compareAndSet(tailTask, task)) {
        tailTask = tail.get();
    }
    tailTask.setNext(task);
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public void testConcurrentDynamicUpdates() throws Throwable {
    createIndex("index");
    final Thread[] indexThreads = new Thread[32];
    final CountDownLatch startLatch = new CountDownLatch(1);
    final AtomicReference<Throwable> error = new AtomicReference<>();
    for (int i = 0; i < indexThreads.length; ++i) {
        final String id = Integer.toString(i);
        indexThreads[i] = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    startLatch.await();
                    assertEquals(DocWriteResponse.Result.CREATED, client().prepareIndex("index", "type", id)
                        .setSource("field" + id, "bar").get().getResult());
                } catch (Exception e) {
                    error.compareAndSet(null, e);
                }
            }
        });
        indexThreads[i].start();
    }
    startLatch.countDown();
    for (Thread thread : indexThreads) {
        thread.join();
    }
    if (error.get() != null) {
        throw error.get();
    }
    Thread.sleep(2000);
    GetMappingsResponse mappings = client().admin().indices().prepareGetMappings("index").setTypes("type").get();
    for (int i = 0; i < indexThreads.length; ++i) {
        assertMappingsHaveField(mappings, "index", "type", "field" + i);
    }
    for (int i = 0; i < indexThreads.length; ++i) {
        assertTrue(client().prepareGet("index", "type", Integer.toString(i)).get().isExists());
    }
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
/**
 * Variant of releaseWaiters that additionally tries to remove any
 * nodes no longer waiting for advance due to timeout or
 * interrupt. Currently, nodes are removed only if they are at
 * head of queue, which suffices to reduce memory footprint in
 * most usages.
 *
 * @return current phase on exit
 */
private int abortWait(int phase) {
    AtomicReference<QNode> head = (phase & 1) == 0 ? evenQ : oddQ;
    for (;;) {
        Thread t;
        QNode q = head.get();
        int p = (int)(root.state >>> PHASE_SHIFT);
        if (q == null || ((t = q.thread) != null && q.phase == p))
            return p;
        if (head.compareAndSet(q, q.next) && t != null) {
            q.thread = null;
            LockSupport.unpark(t);
        }
    }
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public void set(Subscription s) {
    if (s == null) {
        throw new IllegalArgumentException("Subscription can not be null");
    }
    State oldState;
    AtomicReference<State> localState = this.state;
    do {
        oldState = (State) localState.get();
        if (oldState.isUnsubscribed) {
            s.unsubscribe();
            return;
        }
    } while (!localState.compareAndSet(oldState, oldState.set(s)));
    oldState.subscription.unsubscribe();
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public final void compute() {
    final Function<? super V, ? extends U> searchFunction;
    final AtomicReference<U> result;
    if ((searchFunction = this.searchFunction) != null &&
        (result = this.result) != null) {
        for (int i = baseIndex, f, h; batch > 0 &&
                 (h = ((f = baseLimit) + i) >>> 1) > i;) {
            if (result.get() != null)
                return;
            addToPendingCount(1);
            new SearchValuesTask<K,V,U>
                (this, batch >>>= 1, baseLimit = h, f, tab,
                 searchFunction, result).fork();
        }
        while (result.get() == null) {
            U u;
            Node<K,V> p;
            if ((p = advance()) == null) {
                propagateCompletion();
                break;
            }
            if ((u = searchFunction.apply(p.val)) != null) {
                if (result.compareAndSet(null, u))
                    quietlyCompleteRoot();
                break;
            }
        }
    }
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public void unsubscribe() {
    State newState;
    AtomicReference<State> localState = this.state;
    State oldState;
    do {
        oldState = (State) localState.get();
        if (!oldState.isUnsubscribed) {
            newState = oldState.unsubscribe();
        } else {
            return;
        }
    } while (!localState.compareAndSet(oldState, newState));
    unsubscribeActualIfApplicable(newState);
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
/**
 * Atomically updates the target upstream AtomicReference from null to the non-null
 * next Disposable, otherwise disposes next and reports a ProtocolViolationException
 * if the AtomicReference doesn't contain the shared disposed indicator.
 * @param upstream the target AtomicReference to update
 * @param next the Disposable to set on it atomically
 * @param observer the class of the consumer to have a personalized
 * error message if the upstream already contains a non-cancelled Disposable.
 * @return true if successful, false if the content of the AtomicReference was non null
 */
public static boolean setOnce(AtomicReference<Disposable> upstream, Disposable next, Class<?> observer) {
    ObjectHelper.requireNonNull(next, "next is null");
    if (!upstream.compareAndSet(null, next)) {
        next.dispose();
        if (upstream.get() != DisposableHelper.DISPOSED) {
            reportDoubleSubscription(observer);
        }
        return false;
    }
    return true;
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
/**
 * Atomically updates the target upstream AtomicReference from null to the non-null
 * next Subscription, otherwise cancels next and reports a ProtocolViolationException
 * if the AtomicReference doesn't contain the shared cancelled indicator.
 * @param upstream the target AtomicReference to update
 * @param next the Subscription to set on it atomically
 * @param subscriber the class of the consumer to have a personalized
 * error message if the upstream already contains a non-cancelled Subscription.
 * @return true if successful, false if the content of the AtomicReference was non null
 */
public static boolean setOnce(AtomicReference<Subscription> upstream, Subscription next, Class<?> subscriber) {
    ObjectHelper.requireNonNull(next, "next is null");
    if (!upstream.compareAndSet(null, next)) {
        next.cancel();
        if (upstream.get() != SubscriptionHelper.CANCELLED) {
            reportDoubleSubscription(subscriber);
        }
        return false;
    }
    return true;
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public void incInt(String attributeName, Integer newVal, Integer oldVal) {
  if (newVal.equals(oldVal)) {
    return;
  }
  AtomicReference<Number> ar = aggregateMap.get(attributeName);
  for (;;) {
    Number expectedVal = ar.get();
    Number curVal = expectedVal.intValue() + (newVal - oldVal);
    if (ar.compareAndSet(expectedVal, curVal)) {
      return;
    }
  }
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
@Override
public void evaluate() throws Throwable {
    long start = System.currentTimeMillis();
    if (parallel) {
        final CountDownLatch done = new CountDownLatch(times);
        final ExecutorService es = Executors.newCachedThreadPool();
        final AtomicReference<Throwable> anyError = new AtomicReference<>(null);
        try {
            for (int i = 1; i <= times; i++) {
                final int idx = i;
                es.submit(() -> {
                            try {
                                if (anyError.compareAndSet(null, null)) {
                                    if (printStep) {
                                        System.out.println("Repeat(Parallel) " + methodName + ": " + idx + "/" + times);
                                    }
                                    statement.evaluate();
                                }
                            } catch (Throwable throwable) {
                                anyError.compareAndSet(null, throwable);
                            } finally {
                                done.countDown();
                            }
                        }
                );
            }
            done.await();
            if (!anyError.compareAndSet(null, null)) {
                throw anyError.get();
            }
        } finally {
            es.shutdown();
        }
    } else {
        for (int i = 1; i <= times; i++) {
            long lapsed = System.currentTimeMillis() - start;
            long each = (i == 1 ? 0 : lapsed / (i - 1));
            if (printStep) {
                System.out.println("Repeat " + methodName + ": " + i + "/" + times + " elapsed(ms):" + lapsed + " each(ms):" + each);
            }
            statement.evaluate();
        }
    }
}
 

import java.util.concurrent.atomic.AtomicReference; //导入方法依赖的package包/类
public void testThreads() throws Exception {
    final ParentChildIndexFieldData indexFieldData = getForField(childType);
    final DirectoryReader reader = ElasticsearchDirectoryReader.wrap(
            DirectoryReader.open(writer), new ShardId(new Index("test", ""), 0));
    final IndexParentChildFieldData global = indexFieldData.loadGlobal(reader);
    final AtomicReference<Exception> error = new AtomicReference<>();
    final int numThreads = scaledRandomIntBetween(3, 8);
    final Thread[] threads = new Thread[numThreads];
    final CountDownLatch latch = new CountDownLatch(1);

    final Map<Object, BytesRef[]> expected = new HashMap<>();
    for (LeafReaderContext context : reader.leaves()) {
        AtomicParentChildFieldData leafData = global.load(context);
        SortedDocValues parentIds = leafData.getOrdinalsValues(parentType);
        final BytesRef[] ids = new BytesRef[parentIds.getValueCount()];
        for (int j = 0; j < parentIds.getValueCount(); ++j) {
            final BytesRef id = parentIds.lookupOrd(j);
            if (id != null) {
                ids[j] = BytesRef.deepCopyOf(id);
            }
        }
        expected.put(context.reader().getCoreCacheKey(), ids);
    }

    for (int i = 0; i < numThreads; ++i) {
        threads[i] = new Thread() {
            @Override
            public void run() {
                try {
                    latch.await();
                    for (int i = 0; i < 100000; ++i) {
                        for (LeafReaderContext context : reader.leaves()) {
                            AtomicParentChildFieldData leafData = global.load(context);
                            SortedDocValues parentIds = leafData.getOrdinalsValues(parentType);
                            final BytesRef[] expectedIds = expected.get(context.reader().getCoreCacheKey());
                            for (int j = 0; j < parentIds.getValueCount(); ++j) {
                                final BytesRef id = parentIds.lookupOrd(j);
                                assertEquals(expectedIds[j], id);
                            }
                        }
                    }
                } catch (Exception e) {
                    error.compareAndSet(null, e);
                }
            }
        };
        threads[i].start();
    }
    latch.countDown();
    for (Thread thread : threads) {
        thread.join();
    }
    if (error.get() != null) {
        throw error.get();
    }
}