/** * compareAndSet in one thread enables another waiting for value * to succeed */ public void testCompareAndSetInMultipleThreads() throws Exception { x = 1; final AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); Thread t = new Thread(new CheckedRunnable() { public void realRun() { while (!a.compareAndSet(AtomicLongFieldUpdaterTest.this, 2, 3)) Thread.yield(); }}); t.start(); assertTrue(a.compareAndSet(this, 1, 2)); t.join(LONG_DELAY_MS); assertFalse(t.isAlive()); assertEquals(3, a.get(this)); }
static <T> long producedCancellable(AtomicLongFieldUpdater<T> updater, T instance, long n) { for (; ; ) { long current = updater.get(instance); if (current == Long.MIN_VALUE) { return Long.MIN_VALUE; } if (current == Long.MAX_VALUE) { return Long.MAX_VALUE; } long update = current - n; if (update < 0L) { reportBadRequest(update); update = 0L; } if (updater.compareAndSet(instance, current, update)) { return update; } } }
public static <T> long getAndAddRequest(AtomicLongFieldUpdater<T> requested, T object, long n) { long current; do { current = requested.get(object); } while (!requested.compareAndSet(object, current, addCap(current, n))); return current; }
public void checkPrivateAccess() { try { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a = AtomicLongFieldUpdater.newUpdater (AtomicLongFieldUpdaterTest.class, "privateField"); shouldThrow(); } catch (RuntimeException success) { assertNotNull(success.getCause()); } }
public void checkCompareAndSetProtectedSub() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a = AtomicLongFieldUpdater.newUpdater (AtomicLongFieldUpdaterTest.class, "protectedField"); this.protectedField = 1; assertTrue(a.compareAndSet(this, 1, 2)); assertTrue(a.compareAndSet(this, 2, -4)); assertEquals(-4, a.get(this)); assertFalse(a.compareAndSet(this, -5, 7)); assertEquals(-4, a.get(this)); assertTrue(a.compareAndSet(this, -4, 7)); assertEquals(7, a.get(this)); }
public void checkPackageAccess(AtomicLongFieldUpdaterTest obj) { obj.x = 72L; AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a = AtomicLongFieldUpdater.newUpdater (AtomicLongFieldUpdaterTest.class, "x"); assertEquals(72L, a.get(obj)); assertTrue(a.compareAndSet(obj, 72L, 73L)); assertEquals(73L, a.get(obj)); }
public void checkPrivateAccess(AtomicLongFieldUpdaterTest obj) { try { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a = AtomicLongFieldUpdater.newUpdater (AtomicLongFieldUpdaterTest.class, "privateField"); throw new AssertionError("should throw"); } catch (RuntimeException success) { assertNotNull(success.getCause()); } }
/** * get returns the last value set or assigned */ public void testGetSet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(1, a.get(this)); a.set(this, 2); assertEquals(2, a.get(this)); a.set(this, -3); assertEquals(-3, a.get(this)); }
/** * get returns the last value lazySet by same thread */ public void testGetLazySet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(1, a.get(this)); a.lazySet(this, 2); assertEquals(2, a.get(this)); a.lazySet(this, -3); assertEquals(-3, a.get(this)); }
/** * compareAndSet succeeds in changing value if equal to expected else fails */ public void testCompareAndSet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertTrue(a.compareAndSet(this, 1, 2)); assertTrue(a.compareAndSet(this, 2, -4)); assertEquals(-4, a.get(this)); assertFalse(a.compareAndSet(this, -5, 7)); assertEquals(-4, a.get(this)); assertTrue(a.compareAndSet(this, -4, 7)); assertEquals(7, a.get(this)); }
/** * compareAndSet succeeds in changing protected field value if * equal to expected else fails */ public void testCompareAndSetProtected() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("protectedField"); protectedField = 1; assertTrue(a.compareAndSet(this, 1, 2)); assertTrue(a.compareAndSet(this, 2, -4)); assertEquals(-4, a.get(this)); assertFalse(a.compareAndSet(this, -5, 7)); assertEquals(-4, a.get(this)); assertTrue(a.compareAndSet(this, -4, 7)); assertEquals(7, a.get(this)); }
/** * repeated weakCompareAndSet succeeds in changing value when equal * to expected */ public void testWeakCompareAndSet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; do {} while (!a.weakCompareAndSet(this, 1, 2)); do {} while (!a.weakCompareAndSet(this, 2, -4)); assertEquals(-4, a.get(this)); do {} while (!a.weakCompareAndSet(this, -4, 7)); assertEquals(7, a.get(this)); }
/** * getAndSet returns previous value and sets to given value */ public void testGetAndSet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(1, a.getAndSet(this, 0)); assertEquals(0, a.getAndSet(this, -10)); assertEquals(-10, a.getAndSet(this, 1)); }
/** * getAndAdd returns previous value and adds given value */ public void testGetAndAdd() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(1, a.getAndAdd(this, 2)); assertEquals(3, a.get(this)); assertEquals(3, a.getAndAdd(this, -4)); assertEquals(-1, a.get(this)); }
/** * getAndDecrement returns previous value and decrements */ public void testGetAndDecrement() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(1, a.getAndDecrement(this)); assertEquals(0, a.getAndDecrement(this)); assertEquals(-1, a.getAndDecrement(this)); }
/** * getAndIncrement returns previous value and increments */ public void testGetAndIncrement() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(1, a.getAndIncrement(this)); assertEquals(2, a.get(this)); a.set(this, -2); assertEquals(-2, a.getAndIncrement(this)); assertEquals(-1, a.getAndIncrement(this)); assertEquals(0, a.getAndIncrement(this)); assertEquals(1, a.get(this)); }
/** * addAndGet adds given value to current, and returns current value */ public void testAddAndGet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(3, a.addAndGet(this, 2)); assertEquals(3, a.get(this)); assertEquals(-1, a.addAndGet(this, -4)); assertEquals(-1, a.get(this)); }
/** * decrementAndGet decrements and returns current value */ public void testDecrementAndGet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(0, a.decrementAndGet(this)); assertEquals(-1, a.decrementAndGet(this)); assertEquals(-2, a.decrementAndGet(this)); assertEquals(-2, a.get(this)); }
/** * incrementAndGet increments and returns current value */ public void testIncrementAndGet() { AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a; a = updaterFor("x"); x = 1; assertEquals(2, a.incrementAndGet(this)); assertEquals(2, a.get(this)); a.set(this, -2); assertEquals(-1, a.incrementAndGet(this)); assertEquals(0, a.incrementAndGet(this)); assertEquals(1, a.incrementAndGet(this)); assertEquals(1, a.get(this)); }
/** * AtomicLongFieldUpdater getAndUpdate returns previous value and updates * result of supplied function */ public void testLongFieldUpdaterGetAndUpdate() { AtomicLongFieldUpdater a = aLongFieldUpdater(); a.set(this, 1); assertEquals(1L, a.getAndUpdate(this, Atomic8Test::addLong17)); assertEquals(18L, a.getAndUpdate(this, Atomic8Test::addLong17)); assertEquals(35L, a.get(this)); assertEquals(35L, aLongField); }
/** * AtomicLongFieldUpdater updateAndGet updates with supplied function and * returns result. */ public void testLongFieldUpdaterUpdateAndGet() { AtomicLongFieldUpdater a = aLongFieldUpdater(); a.set(this, 1); assertEquals(18L, a.updateAndGet(this, Atomic8Test::addLong17)); assertEquals(35L, a.updateAndGet(this, Atomic8Test::addLong17)); assertEquals(35L, a.get(this)); assertEquals(35L, aLongField); }
/** * AtomicLongFieldUpdater getAndAccumulate returns previous value * and updates with supplied function. */ public void testLongFieldUpdaterGetAndAccumulate() { AtomicLongFieldUpdater a = aLongFieldUpdater(); a.set(this, 1); assertEquals(1L, a.getAndAccumulate(this, 2L, Long::sum)); assertEquals(3L, a.getAndAccumulate(this, 3L, Long::sum)); assertEquals(6L, a.get(this)); assertEquals(6L, aLongField); }
/** * AtomicLongFieldUpdater accumulateAndGet updates with supplied * function and returns result. */ public void testLongFieldUpdaterAccumulateAndGet() { AtomicLongFieldUpdater a = aLongFieldUpdater(); a.set(this, 1); assertEquals(7L, a.accumulateAndGet(this, 6L, Long::sum)); assertEquals(10L, a.accumulateAndGet(this, 3L, Long::sum)); assertEquals(10L, a.get(this)); assertEquals(10L, aLongField); }
/** * Object arguments for parameters of type T that are not * instances of the class passed to the newUpdater call will * result in a ClassCastException being thrown. */ public void testFieldUpdaters_ClassCastException() { // Use raw types to allow passing wrong object type, provoking CCE final AtomicLongFieldUpdater longUpdater = aLongFieldUpdater(); final AtomicIntegerFieldUpdater intUpdater = anIntFieldUpdater(); final AtomicReferenceFieldUpdater refUpdater = anIntegerFieldUpdater(); final Object obj = new Object(); for (Object x : new Object[]{ new Object(), null }) { Runnable[] throwingActions = { () -> longUpdater.get(x), () -> intUpdater.get(x), () -> refUpdater.get(x), () -> longUpdater.set(x, 17L), () -> intUpdater.set(x, 17), () -> refUpdater.set(x, (Integer) 17), () -> longUpdater.addAndGet(x, 17L), () -> intUpdater.addAndGet(x, 17), () -> longUpdater.getAndUpdate(x, y -> y), () -> intUpdater.getAndUpdate(x, y -> y), () -> refUpdater.getAndUpdate(x, y -> y), () -> longUpdater.compareAndSet(x, 17L, 42L), () -> intUpdater.compareAndSet(x, 17, 42), () -> refUpdater.compareAndSet(x, (Integer) 17, (Integer) 42), }; assertThrows(ClassCastException.class, throwingActions); } }
