Java AtomicReferenceArray.compareAndSet方法代碼示例

import java.util.concurrent.atomic.AtomicReferenceArray; //導入方法依賴的package包/類
/**
 * compareAndSet in one thread enables another waiting for value
 * to succeed
 */
public void testCompareAndSetInMultipleThreads() throws InterruptedException {
    final AtomicReferenceArray a = new AtomicReferenceArray(1);
    a.set(0, one);
    Thread t = new Thread(new CheckedRunnable() {
        public void realRun() {
            while (!a.compareAndSet(0, two, three))
                Thread.yield();
        }});

    t.start();
    assertTrue(a.compareAndSet(0, one, two));
    t.join(LONG_DELAY_MS);
    assertFalse(t.isAlive());
    assertSame(three, a.get(0));
}
 

import java.util.concurrent.atomic.AtomicReferenceArray; //導入方法依賴的package包/類
private boolean doRemove(final Item<K, V> item, final Table<K, V> table) {
    int hashCode = item.hashCode;

    final AtomicReferenceArray<Item<K, V>[]> array = table.array;
    final int idx = hashCode & array.length() - 1;

    Item<K, V>[] oldRow;

    for (;;) {
        oldRow = array.get(idx);
        if (oldRow == null) {
            return false;
        }
        if (oldRow == RESIZED) {
            boolean result;
            if (result = doRemove(item, table.resizeView)) {
                sizeUpdater.getAndDecrement(table);
            }
            return result;
        }

        int rowIdx = -1;
        for (int i = 0; i < oldRow.length; i ++) {
            if (item == oldRow[i]) {
                rowIdx = i;
                break;
            }
        }
        if (rowIdx == -1) {
            return false;
        }
        if (array.compareAndSet(idx, oldRow, remove(oldRow, rowIdx))) {
            sizeUpdater.getAndDecrement(table);
            return true;
        }
        // row changed, cycle back again
    }
}
 

import java.util.concurrent.atomic.AtomicReferenceArray; //導入方法依賴的package包/類
private void basicFree(long addr, int idx,
    AtomicReferenceArray<OffHeapStoredObjectAddressStack> freeLists) {
  OffHeapStoredObjectAddressStack clq = freeLists.get(idx);
  if (clq != null) {
    clq.offer(addr);
  } else {
    clq = createFreeListForEmptySlot(freeLists, idx);
    clq.offer(addr);
    if (!freeLists.compareAndSet(idx, null, clq)) {
      clq = freeLists.get(idx);
      clq.offer(addr);
    }
  }
}
 

import java.util.concurrent.atomic.AtomicReferenceArray; //導入方法依賴的package包/類
@Override
protected OffHeapStoredObjectAddressStack createFreeListForEmptySlot(
    AtomicReferenceArray<OffHeapStoredObjectAddressStack> freeLists, int idx) {
  if (this.firstTime) {
    this.firstTime = false;
    OffHeapStoredObjectAddressStack clq = super.createFreeListForEmptySlot(freeLists, idx);
    if (!freeLists.compareAndSet(idx, null, clq)) {
      fail("this should never happen. Indicates a concurrent modification");
    }
  }
  return super.createFreeListForEmptySlot(freeLists, idx);
}
 

import java.util.concurrent.atomic.AtomicReferenceArray; //導入方法依賴的package包/類
private V doPut(K key, V value, boolean ifAbsent, Table<K, V> table) {
    final int hashCode = hashOf(key);
    final AtomicReferenceArray<Item<K, V>[]> array = table.array;
    final int idx = hashCode & array.length() - 1;

    OUTER: for (;;) {

        // Fetch the table row.
        Item<K, V>[] oldRow = array.get(idx);
        if (oldRow == RESIZED) {
            // row was transported to the new table so recalculate everything
            final V result = doPut(key, value, ifAbsent, table.resizeView);
            // keep a consistent size view though!
            if (result == NONEXISTENT) sizeUpdater.getAndIncrement(table);
            return result;
        }
        if (oldRow != null) {
            // Find the matching Item in the row.
            Item<K, V> oldItem = null;
            for (Item<K, V> tryItem : oldRow) {
                if (equals(key, tryItem.key)) {
                    oldItem = tryItem;
                    break;
                }
            }
            if (oldItem != null) {
                // entry exists; try to return the old value and try to replace the value if allowed.
                V oldItemValue;
                do {
                    oldItemValue = oldItem.value;
                    if (oldItemValue == NONEXISTENT) {
                        // Key was removed; on the next iteration or two the doornail should be gone.
                        continue OUTER;
                    }
                } while (! ifAbsent && ! valueUpdater.compareAndSet(oldItem, oldItemValue, value));
                return oldItemValue;
            }
            // Row exists but item doesn't.
        }

        // Row doesn't exist, or row exists but item doesn't; try and add a new item to the row.
        final Item<K, V> newItem = new Item<>(key, hashCode, value);
        final Item<K, V>[] newRow = addItem(oldRow, newItem);
        if (! array.compareAndSet(idx, oldRow, newRow)) {
            // Nope, row changed; retry.
            continue;
        }

        // Up the table size.
        final int threshold = table.threshold;
        int newSize = sizeUpdater.incrementAndGet(table);
        // >= 0 is really a sign-bit check
        while (newSize >= 0 && (newSize & 0x7fffffff) > threshold) {
            if (sizeUpdater.compareAndSet(table, newSize, newSize | 0x80000000)) {
                resize(table);
                return nonexistent();
            }
            newSize = sizeUpdater.get(table);
        }
        // Success.
        return nonexistent();
    }
}