Java 类java.util.concurrent.atomic.AtomicStampedReference 实例源码

/**
 * get returns the last values of reference and stamp set
 */
public void testGetSet() {
    int[] mark = new int[1];
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertSame(one, ai.getReference());
    assertEquals(0, ai.getStamp());
    assertSame(one, ai.get(mark));
    assertEquals(0, mark[0]);
    ai.set(two, 0);
    assertSame(two, ai.getReference());
    assertEquals(0, ai.getStamp());
    assertSame(two, ai.get(mark));
    assertEquals(0, mark[0]);
    ai.set(one, 1);
    assertSame(one, ai.getReference());
    assertEquals(1, ai.getStamp());
    assertSame(one, ai.get(mark));
    assertEquals(1, mark[0]);
}

/**
 * compareAndSet succeeds in changing values if equal to expected reference
 * and stamp else fails
 */
public void testCompareAndSet() {
    int[] mark = new int[1];
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertSame(one, ai.get(mark));
    assertEquals(0, ai.getStamp());
    assertEquals(0, mark[0]);

    assertTrue(ai.compareAndSet(one, two, 0, 0));
    assertSame(two, ai.get(mark));
    assertEquals(0, mark[0]);

    assertTrue(ai.compareAndSet(two, m3, 0, 1));
    assertSame(m3, ai.get(mark));
    assertEquals(1, mark[0]);

    assertFalse(ai.compareAndSet(two, m3, 1, 1));
    assertSame(m3, ai.get(mark));
    assertEquals(1, mark[0]);
}

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

    t.start();
    assertTrue(ai.compareAndSet(one, two, 0, 0));
    t.join(LONG_DELAY_MS);
    assertFalse(t.isAlive());
    assertSame(three, ai.getReference());
    assertEquals(0, ai.getStamp());
}

/**
 * compareAndSet in one thread enables another waiting for stamp value
 * to succeed
 */
public void testCompareAndSetInMultipleThreads2() throws Exception {
    final AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    Thread t = new Thread(new CheckedRunnable() {
        public void realRun() {
            while (!ai.compareAndSet(one, one, 1, 2))
                Thread.yield();
        }});

    t.start();
    assertTrue(ai.compareAndSet(one, one, 0, 1));
    t.join(LONG_DELAY_MS);
    assertFalse(t.isAlive());
    assertSame(one, ai.getReference());
    assertEquals(2, ai.getStamp());
}

/**
 * repeated weakCompareAndSet succeeds in changing values when equal
 * to expected
 */
public void testWeakCompareAndSet() {
    int[] mark = new int[1];
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertSame(one, ai.get(mark));
    assertEquals(0, ai.getStamp());
    assertEquals(0, mark[0]);

    do {} while (!ai.weakCompareAndSet(one, two, 0, 0));
    assertSame(two, ai.get(mark));
    assertEquals(0, mark[0]);

    do {} while (!ai.weakCompareAndSet(two, m3, 0, 1));
    assertSame(m3, ai.get(mark));
    assertEquals(1, mark[0]);
}

/**
 * get returns the last values of reference and stamp set
 */
public void testGetSet() {
    int[] mark = new int[1];
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertSame(one, ai.getReference());
    assertEquals(0, ai.getStamp());
    assertSame(one, ai.get(mark));
    assertEquals(0, mark[0]);
    ai.set(two, 0);
    assertSame(two, ai.getReference());
    assertEquals(0, ai.getStamp());
    assertSame(two, ai.get(mark));
    assertEquals(0, mark[0]);
    ai.set(one, 1);
    assertSame(one, ai.getReference());
    assertEquals(1, ai.getStamp());
    assertSame(one, ai.get(mark));
    assertEquals(1, mark[0]);
}

/**
 * compareAndSet succeeds in changing values if equal to expected reference
 * and stamp else fails
 */
public void testCompareAndSet() {
    int[] mark = new int[1];
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertSame(one, ai.get(mark));
    assertEquals(0, ai.getStamp());
    assertEquals(0, mark[0]);

    assertTrue(ai.compareAndSet(one, two, 0, 0));
    assertSame(two, ai.get(mark));
    assertEquals(0, mark[0]);

    assertTrue(ai.compareAndSet(two, m3, 0, 1));
    assertSame(m3, ai.get(mark));
    assertEquals(1, mark[0]);

    assertFalse(ai.compareAndSet(two, m3, 1, 1));
    assertSame(m3, ai.get(mark));
    assertEquals(1, mark[0]);
}

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

    t.start();
    assertTrue(ai.compareAndSet(one, two, 0, 0));
    t.join(LONG_DELAY_MS);
    assertFalse(t.isAlive());
    assertSame(three, ai.getReference());
    assertEquals(0, ai.getStamp());
}

/**
 * compareAndSet in one thread enables another waiting for stamp value
 * to succeed
 */
public void testCompareAndSetInMultipleThreads2() throws Exception {
    final AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    Thread t = new Thread(new CheckedRunnable() {
        public void realRun() {
            while (!ai.compareAndSet(one, one, 1, 2))
                Thread.yield();
        }});

    t.start();
    assertTrue(ai.compareAndSet(one, one, 0, 1));
    t.join(LONG_DELAY_MS);
    assertFalse(t.isAlive());
    assertSame(one, ai.getReference());
    assertEquals(2, ai.getStamp());
}

/**
 * repeated weakCompareAndSet succeeds in changing values when equal
 * to expected
 */
public void testWeakCompareAndSet() {
    int[] mark = new int[1];
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertSame(one, ai.get(mark));
    assertEquals(0, ai.getStamp());
    assertEquals(0, mark[0]);

    do {} while (!ai.weakCompareAndSet(one, two, 0, 0));
    assertSame(two, ai.get(mark));
    assertEquals(0, mark[0]);

    do {} while (!ai.weakCompareAndSet(two, m3, 0, 1));
    assertSame(m3, ai.get(mark));
    assertEquals(1, mark[0]);
}

private AtomicStampedReference<KAryBaseNode> searchKey(int key, KAryInternalNode l){
    if(l.keys[0] == Integer.MAX_VALUE)
        return l.children.get(0);
    int left = 0;
    int right = l.keyCount-1;
    while(right > left){
        int mid = (left+right)/2;
        if( key < l.keys[mid]){
            right = mid;
        }
        else{
            left = mid+1;
        }
    }
    if(left == l.keyCount-1 && (key >= l.keys[left]) )
        return l.children.get(l.keyCount);
    return l.children.get(left);
}

public KAryInternalNode(int K, boolean root){
    this.keys = new int[K-1];
    this.keyCount = K-1;
    for(int i = 0; i < keyCount; ++i){
        this.keys[i] = Integer.MAX_VALUE;
    }
    if(root){
        this.children = new ArrayList<AtomicStampedReference<KAryBaseNode>>(K);
        this.children.add(new AtomicStampedReference<KAryBaseNode>(new KAryInternalNode(K,false),0 ) );
        for(int i = 1; i < K; ++i ){
            this.children.add(new AtomicStampedReference<KAryBaseNode>(new KAryLeafNode(K),0) );
        }
    }
    else{
        this.children = new ArrayList<AtomicStampedReference<KAryBaseNode>>(K);
        for(int i = 0; i < K; ++i ){
            this.children.add(new AtomicStampedReference<KAryBaseNode>(new KAryLeafNode(K),0));
        }
    }
}

public KAryInternalNode(int key, KAryBaseNode leaf){
    this.keyCount = leaf.keyCount;
    int i;
    for(i = 0; i < keyCount; ++i){
        if( key < leaf.keys[i])
            break;
    }
    this.children = new ArrayList<AtomicStampedReference<KAryBaseNode>>(keyCount+1);
    for(int j = 0; j < i; ++j){
        //this.children.set(j, new KAryLeafNode(leaf.keys[j],true));
        this.children.set(j, new AtomicStampedReference<KAryBaseNode>(new KAryLeafNode(leaf.keys[j],true),0));
    }
    //this.children.set(i, new KAryLeafNode(key,true));
    this.children.set(i, new AtomicStampedReference<KAryBaseNode>(new KAryLeafNode(key,true),0));
    for(int j = i ; j < keyCount; ++j){
        //this.children.set(j+1, new KAryLeafNode(leaf.keys[j],true));
        this.children.set(j+1, new AtomicStampedReference<KAryBaseNode>(new KAryLeafNode(leaf.keys[j],true),0));
    }
    this.keys = new int[keyCount];
    int []stamp = new int[1];
    for(int j = 0; j < keyCount; ++j){
        //this.keys[j] = this.children.get(j+1).keys[0];
        this.keys[j] = this.children.get(j+1).get(stamp).keys[0];
    }
}

public void setRunning() {
    AtomicStampedReference<State> stateRef = state;
    int newStamp = stamp.incrementAndGet();
    int[] receiver = new int[1];
    // Keep trying until stateRef is set with our stamp
    for (;;) {
        State was = stateRef.get(receiver);
        if (was != State.STARTING) { // AS7-1103 only transition to running from STARTING
            break;
        }
        synchronized (service) {
            State newState = restartRequiredFlag ? State.RESTART_REQUIRED : State.RUNNING;
            if (state.compareAndSet(was, newState, receiver[0], newStamp)) {
                service.stateChanged(newState);
                break;
            }
        }
    }
}

public Object setReloadRequired() {
    if (!reloadSupported) {
        return setRestartRequired();
    }
    AtomicStampedReference<State> stateRef = state;
    int newStamp = stamp.incrementAndGet();
    int[] receiver = new int[1];
    // Keep trying until stateRef is RELOAD_REQUIRED with our stamp
    for (;;) {
        State was = stateRef.get(receiver);
        if (was == State.STARTING || was == State.STOPPING || was == State.RESTART_REQUIRED) {
            break;
        }
        synchronized (service) {
            if (stateRef.compareAndSet(was, State.RELOAD_REQUIRED, receiver[0], newStamp)) {
                service.stateChanged(State.RELOAD_REQUIRED);
                break;
            }
        }
    }
    return Integer.valueOf(newStamp);
}

public Object setRestartRequired() {
    AtomicStampedReference<State> stateRef = state;
    int newStamp = stamp.incrementAndGet();
    int[] receiver = new int[1];
    // Keep trying until stateRef is RESTART_REQUIRED with our stamp
    for (;;) {
        State was = stateRef.get(receiver);
        if (was == State.STARTING || was == State.STOPPING) {
            break;
        }
        synchronized (service) {
            if (stateRef.compareAndSet(was, State.RESTART_REQUIRED, receiver[0], newStamp)) {
                restartRequiredFlag = true;
                service.stateChanged(State.RESTART_REQUIRED);
                break;
            }
        }
    }
    return Integer.valueOf(newStamp);
}

@Override
public WorkloadStatusSnapshot status() throws MetricsCollectionException
{
    if ( null != alreadyShutdownPolicy )
    {
        alreadyShutdownPolicy.apply();
    }
    AtomicStampedReference<WorkloadStatusSnapshot> statusSnapshotReference = eventHandler.statusSnapshot();
    int oldStamp = statusSnapshotReference.getStamp();
    ringBuffer.publishEvent( getWorkloadStatusTranslator );
    while ( statusSnapshotReference.getStamp() <= oldStamp )
    {
        LockSupport.parkNanos( TimeUnit.MILLISECONDS.toNanos( 100 ) );
    }
    return statusSnapshotReference.getReference();
}

@Override
public WorkloadResultsSnapshot results() throws MetricsCollectionException
{
    if ( null != alreadyShutdownPolicy )
    {
        alreadyShutdownPolicy.apply();
    }
    AtomicStampedReference<WorkloadResultsSnapshot> resultsSnapshotReference = eventHandler.resultsSnapshot();
    int oldStamp = resultsSnapshotReference.getStamp();
    ringBuffer.publishEvent( getWorkloadResultsTranslator );
    while ( resultsSnapshotReference.getStamp() <= oldStamp )
    {
        LockSupport.parkNanos( TimeUnit.MILLISECONDS.toNanos( 100 ) );
    }
    return resultsSnapshotReference.getReference();
}

@Test
public void should_create_error_message_for_AtomicStampedReference() throws Exception {
  // GIVEN
  AtomicStampedReference<String> actual = new AtomicStampedReference<>("foo", 123);
  // WHEN
  String message = shouldHaveReference(actual, actual.getReference(), "bar").create(TEST_DESCRIPTION,
                                                                                    CONFIGURATION_PROVIDER.representation());
  // THEN
  assertThat(message).isEqualTo(format("[TEST] %n" +
                                       "Expecting%n" +
                                       "  <AtomicStampedReference[stamp=123, reference=\"foo\"]>%n" +
                                       "to have reference:%n" +
                                       "  <\"bar\">%n" +
                                       "but had:%n" +
                                       "  <\"foo\">"));
}

/**
 * constructor initializes to given reference and stamp
 */
public void testConstructor() {
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertSame(one, ai.getReference());
    assertEquals(0, ai.getStamp());
    AtomicStampedReference a2 = new AtomicStampedReference(null, 1);
    assertNull(a2.getReference());
    assertEquals(1, a2.getStamp());
}

/**
 * attemptStamp succeeds in single thread
 */
public void testAttemptStamp() {
    int[] mark = new int[1];
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertEquals(0, ai.getStamp());
    assertTrue(ai.attemptStamp(one, 1));
    assertEquals(1, ai.getStamp());
    assertSame(one, ai.get(mark));
    assertEquals(1, mark[0]);
}

public static void main(String[] args) {
    AtomicInteger atomicInteger = new AtomicInteger();
    System.out.println(atomicInteger.get());
    System.out.println(atomicInteger.incrementAndGet());
    AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1,0);
    System.out.println(atomicInteger);
}

/**
 * constructor initializes to given reference and stamp
 */
public void testConstructor() {
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertSame(one, ai.getReference());
    assertEquals(0, ai.getStamp());
    AtomicStampedReference a2 = new AtomicStampedReference(null, 1);
    assertNull(a2.getReference());
    assertEquals(1, a2.getStamp());
}

/**
 * attemptStamp succeeds in single thread
 */
public void testAttemptStamp() {
    int[] mark = new int[1];
    AtomicStampedReference ai = new AtomicStampedReference(one, 0);
    assertEquals(0, ai.getStamp());
    assertTrue(ai.attemptStamp(one, 1));
    assertEquals(1, ai.getStamp());
    assertSame(one, ai.get(mark));
    assertEquals(1, mark[0]);
}

public boolean containsKey(int key){
    if(key == -1)
        return false;
    int[] stamp = new int[1];
    KAryBaseNode l = root.children.get(0).get(stamp);
    while( l!= null && !l.isLeaf()){
        AtomicStampedReference<KAryBaseNode> baseNode = searchKey(key, (KAryInternalNode)l);
        l = baseNode.get(stamp);
    }
    if(l == null){
        return false;
    }
    return ((KAryLeafNode)l).hasKey(key);
}

private void helpMarked(DeleteInfo info){
    int[]stamp = new int[1];
    KAryBaseNode other = info.p.children.get(info.p.keyCount).get(stamp);
    int index = 0;
    for(int i = 0; i < info.p.keyCount ;++i){
        KAryBaseNode u = info.p.children.get(i).getReference();
        if( u!= null && u.keyCount > 0 && u != info.oldChild ){
            other = u;
            index = i;
            break;
        }
    }
    boolean casValue = false;
    casValue = info.gp.children.get(info.gpindex).compareAndSet(info.p, other, info.parentStamp, info.parentStamp+1);

    if(casValue){
        KAryInternalNode parentNode = (KAryInternalNode)info.p;
        for(int i = 0; i < K ; ++i){
            AtomicStampedReference<KAryBaseNode> recycledStamp;
            KAryBaseNode recycledNode;

            if(i != info.pindex){
                recycledStamp = parentNode.children.get(i);
                recycledNode = recycledStamp.getReference();
                //recycledStamp.set(null,stamp[0]+1);
                if(recycledNode != null){
                    for(int j = 0; j < K-1; ++j ){
                        recycledNode.keys[j] = Integer.MAX_VALUE;
                    }
                    recycledNode.keyCount = 0;
                    moveToLeafFree(recycledNode);
                }
            }
        }
        parentNode.info = new Clean();
        parentNode.keyCount = 0;
        moveToInternalFree(parentNode);
        infoUpdater.compareAndSet((KAryInternalNode)info.gp, info, new Clean());
    }
}

@SuppressWarnings("unchecked")
@Override
public AtomicStampedReference readObject(OInput in, Class<AtomicStampedReference> clazz) throws IOException {
    Object obj = in.readObject();
    int stamp = in.readInt();
    AtomicStampedReference ref = new AtomicStampedReference(obj, stamp);
    return ref;
}

/**
 * Creates a Bloom filter that can store up to an expected maximum capacity with an acceptable probability
 * that a membership query will result in a false positive. The filter will size itself based on the given
 * parameters.
 *
 * @param capacity    The expected maximum number of elements to be inserted into the Bloom filter.
 * @param probability The acceptable false positive probability for membership queries.
 */
public ConcurrentBloomFilter(int capacity, float probability) {
  if ((capacity <= 0) || (probability <= 0) || (probability >= 1)) {
    throw new IllegalArgumentException();
  }
  this.capacity = max(capacity, Long.SIZE);
  this.bits = bits(capacity, probability);
  this.length = bits / Long.SIZE;
  this.lock = new ReentrantLock();
  this.hashes = numberOfHashes(capacity, bits);
  this.probability = probability(hashes, capacity, bits);
  this.ref = new AtomicStampedReference<long[]>(new long[length], 0);
}

/**
 * Returns standard the {@code toString} representation of the given object. It may or not the object's own
 * implementation of {@code toString}.
 * 
 * @param object the given object.
 * @return the {@code toString} representation of the given object.
 */
@Override
public String toStringOf(Object object) {
  if (object == null) return null;
  if (hasCustomFormatterFor(object)) return customFormat(object);
  if (object instanceof Calendar) return toStringOf((Calendar) object);
  if (object instanceof Class<?>) return toStringOf((Class<?>) object);
  if (object instanceof Date) return toStringOf((Date) object);
  if (object instanceof AtomicBoolean) return toStringOf((AtomicBoolean) object);
  if (object instanceof AtomicInteger) return toStringOf((AtomicInteger) object);
  if (object instanceof AtomicLong) return toStringOf((AtomicLong) object);
  if (object instanceof AtomicReference) return toStringOf((AtomicReference<?>) object);
  if (object instanceof AtomicMarkableReference) return toStringOf((AtomicMarkableReference<?>) object);
  if (object instanceof AtomicStampedReference) return toStringOf((AtomicStampedReference<?>) object);
  if (object instanceof AtomicIntegerFieldUpdater) return AtomicIntegerFieldUpdater.class.getSimpleName();
  if (object instanceof AtomicLongFieldUpdater) return AtomicLongFieldUpdater.class.getSimpleName();
  if (object instanceof AtomicReferenceFieldUpdater) return AtomicReferenceFieldUpdater.class.getSimpleName();
  if (object instanceof Number) return toStringOf((Number) object);
  if (object instanceof File) return toStringOf((File) object);
  if (object instanceof String) return toStringOf((String) object);
  if (object instanceof Character) return toStringOf((Character) object);
  if (object instanceof Comparator) return toStringOf((Comparator<?>) object);
  if (object instanceof SimpleDateFormat) return toStringOf((SimpleDateFormat) object);
  if (object instanceof PredicateDescription) return toStringOf((PredicateDescription) object);
  if (object instanceof CompletableFuture) return toStringOf((CompletableFuture<?>) object);
  if (isArray(object)) return formatArray(object);
  if (object instanceof Collection<?>) return smartFormat((Collection<?>) object);
  if (object instanceof Map<?, ?>) return toStringOf((Map<?, ?>) object);
  if (object instanceof Tuple) return toStringOf((Tuple) object);
  if (object instanceof MapEntry) return toStringOf((MapEntry<?, ?>) object);
  if (object instanceof Method) return ((Method) object).toGenericString();
  if (object instanceof InsertDelta<?>) return toStringOf((InsertDelta<?>) object);
  if (object instanceof ChangeDelta<?>) return toStringOf((ChangeDelta<?>) object);
  if (object instanceof DeleteDelta<?>) return toStringOf((DeleteDelta<?>) object);
  return object == null ? null : fallbackToStringOf(object);
}

@Test
public void should_create_error_message() throws Exception {
  // GIVEN
  AtomicStampedReference<String> actual = new AtomicStampedReference<>("foo", 1234);
  // WHEN
  String message = shouldHaveStamp(actual, 5678).create(new TestDescription("TEST"), CONFIGURATION_PROVIDER.representation());
  // THEN
  assertThat(message).isEqualTo(format("[TEST] %n" +
                                       "Expecting%n" +
                                       "  <AtomicStampedReference[stamp=1234, reference=\"foo\"]>%n" +
                                       "to have stamp:%n" +
                                       "  <5678>%n" +
                                       "but had:%n" +
                                       "  <1234>"));
}

@Test
public void should_fail_if_expected_value_is_null_and_does_not_contains_expected_value() throws Exception {
  AtomicStampedReference<String> actual = new AtomicStampedReference<>("actual", 1234);
  thrown.expectAssertionError(shouldHaveReference(actual, actual.getReference(), null).create());

  assertThat(actual).hasReference(null);
}

@Test
public void should_fail_if_atomicStampedReference_does_not_contain_expected_value() throws Exception {
  AtomicStampedReference<String> actual = new AtomicStampedReference<>("actual", 1234);

  thrown.expectAssertionError(shouldHaveReference(actual, actual.getReference(), expectedValue).create());

  assertThat(actual).hasReference(expectedValue);
}

@Test
public void should_fail_if_atomicStampedReference_contains_expected_value_and_hasStamp_does_not() throws Exception {
  int actualStamp = 1234;
  int expectedStamp = 5678;
  AtomicStampedReference<String> actual = new AtomicStampedReference<>(expectedValue, actualStamp);
  thrown.expectAssertionError(shouldHaveStamp(actual, expectedStamp).create());
  assertThat(actual).hasReference(expectedValue).hasStamp(expectedStamp);
}

UpdateInfo(Info info, int state){
    infoRef = new AtomicStampedReference<Info>(info, state);
}

@Override
public void writeObject(OOutput out, AtomicStampedReference ref) throws IOException {
    out.writeObject(ref.getReference());
    out.writeInt(ref.getStamp());
}

AtomicStampedReference<WorkloadStatusSnapshot> statusSnapshot()
{
    return statusSnapshotReference;
}

AtomicStampedReference<WorkloadResultsSnapshot> resultsSnapshot()
{
    return resultsSnapshotReference;
}

private ShouldHaveStamp(AtomicStampedReference<?> actual, int expectedStamp) {
  super(SHOULD_HAVE_STAMP, actual, expectedStamp, actual.getStamp());
}

public static ErrorMessageFactory shouldHaveStamp(AtomicStampedReference<?> actual, int expectedStamp) {
  return new ShouldHaveStamp(actual, expectedStamp);
}

public AtomicStampedReferenceAssert(AtomicStampedReference<VALUE> actual) {
  super(actual, AtomicStampedReferenceAssert.class, true);
}