Java AtomicReferenceFieldUpdater.set方法代码示例

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * AtomicReferenceFieldUpdater getAndUpdate returns previous value
 * and updates result of supplied function
 */
public void testReferenceFieldUpdaterGetAndUpdate() {
    AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
    a.set(this, one);
    assertEquals((Integer) 1, a.getAndUpdate(this, Atomic8Test::addInteger17));
    assertEquals((Integer) 18, a.getAndUpdate(this, Atomic8Test::addInteger17));
    assertEquals((Integer) 35, a.get(this));
    assertEquals((Integer) 35, anIntegerField);
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * AtomicReferenceFieldUpdater updateAndGet updates with supplied
 * function and returns result.
 */
public void testReferenceFieldUpdaterUpdateAndGet() {
    AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
    a.set(this, one);
    assertEquals((Integer) 18, a.updateAndGet(this, Atomic8Test::addInteger17));
    assertEquals((Integer) 35, a.updateAndGet(this, Atomic8Test::addInteger17));
    assertEquals((Integer) 35, a.get(this));
    assertEquals((Integer) 35, anIntegerField);
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * AtomicReferenceFieldUpdater returns previous value and updates
 * with supplied function.
 */
public void testReferenceFieldUpdaterGetAndAccumulate() {
    AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
    a.set(this, one);
    assertEquals((Integer) 1, a.getAndAccumulate(this, 2, Atomic8Test::sumInteger));
    assertEquals((Integer) 3, a.getAndAccumulate(this, 3, Atomic8Test::sumInteger));
    assertEquals((Integer) 6, a.get(this));
    assertEquals((Integer) 6, anIntegerField);
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * AtomicReferenceFieldUpdater accumulateAndGet updates with
 * supplied function and returns result.
 */
public void testReferenceFieldUpdaterAccumulateAndGet() {
    AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
    a.set(this, one);
    assertEquals((Integer) 7, a.accumulateAndGet(this, 6, Atomic8Test::sumInteger));
    assertEquals((Integer) 10, a.accumulateAndGet(this, 3, Atomic8Test::sumInteger));
    assertEquals((Integer) 10, a.get(this));
    assertEquals((Integer) 10, anIntegerField);
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * 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);
    }
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * get returns the last value set or assigned
 */
public void testGetSet() {
    AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
    a = updaterFor("x");
    x = one;
    assertSame(one, a.get(this));
    a.set(this, two);
    assertSame(two, a.get(this));
    a.set(this, m3);
    assertSame(m3, a.get(this));
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * AtomicReferenceFieldUpdater getAndUpdate returns previous value
 * and updates result of supplied function
 */
public void testReferenceFieldUpdaterGetAndUpdate() {
    AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
    a.set(this, one);
    assertEquals(new Integer(1), a.getAndUpdate(this, Atomic8Test::addInteger17));
    assertEquals(new Integer(18), a.getAndUpdate(this, Atomic8Test::addInteger17));
    assertEquals(new Integer(35), a.get(this));
    assertEquals(new Integer(35), anIntegerField);
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * AtomicReferenceFieldUpdater updateAndGet updates with supplied
 * function and returns result.
 */
public void testReferenceFieldUpdaterUpdateAndGet() {
    AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
    a.set(this, one);
    assertEquals(new Integer(18), a.updateAndGet(this, Atomic8Test::addInteger17));
    assertEquals(new Integer(35), a.updateAndGet(this, Atomic8Test::addInteger17));
    assertEquals(new Integer(35), a.get(this));
    assertEquals(new Integer(35), anIntegerField);
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * AtomicReferenceFieldUpdater returns previous value and updates
 * with supplied function.
 */
public void testReferenceFieldUpdaterGetAndAccumulate() {
    AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
    a.set(this, one);
    assertEquals(new Integer(1), a.getAndAccumulate(this, 2, Atomic8Test::sumInteger));
    assertEquals(new Integer(3), a.getAndAccumulate(this, 3, Atomic8Test::sumInteger));
    assertEquals(new Integer(6), a.get(this));
    assertEquals(new Integer(6), anIntegerField);
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * AtomicReferenceFieldUpdater accumulateAndGet updates with
 * supplied function and returns result.
 */
public void testReferenceFieldUpdaterAccumulateAndGet() {
    AtomicReferenceFieldUpdater<Atomic8Test,Integer> a = anIntegerFieldUpdater();
    a.set(this, one);
    assertEquals(new Integer(7), a.accumulateAndGet(this, 6, Atomic8Test::sumInteger));
    assertEquals(new Integer(10), a.accumulateAndGet(this, 3, Atomic8Test::sumInteger));
    assertEquals(new Integer(10), a.get(this));
    assertEquals(new Integer(10), anIntegerField);
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * Creates a new DependencyManager
 * @param script The script to manage dependencies for
 * @param type The script type
 */
public DependencyManager(final T script, final Class<T> type) {
	this.script = script;
	scriptName = this.script.getClass().getName();
	log = LogManager.getLogger(type);

	cache = GlobalCacheService.getInstance();
	try {
		for(Field f: type.getDeclaredFields()) {
			final Dependency d = f.getAnnotation(Dependency.class);
			if(d!=null) {
				final String cacheKey = d.value().trim();
				depFields.put(cacheKey, f);
				depDefs.put(cacheKey, d);
				f.setAccessible(true);
				final AtomicReferenceFieldUpdater<T, Object> updater =  AtomicReferenceFieldUpdater.newUpdater(type, Object.class, f.getName());
				depUpdaters.put(cacheKey, updater);
				final Object o = cache.getOrNotify(cacheKey, d.type(), this, d.timeout(), d.unit());
				if(o==null) {
					script.addPendingDependency(cacheKey);
				} else {
					log.info("Seting dependent value [{}] on [{}] from cache entry [{}]", o.getClass().getName(), scriptName, cacheKey);
					updater.set(script, o);
					//PrivateAccessor.setFieldValue(script, f.getName(), o);
					cache.addCacheEventListener(this, cacheKey);
					log.info("Dependent value [{}] initialized on [{}] from cache entry [{}]", o.getClass().getName(), scriptName, cacheKey);
				}
			}
		}
	} catch (Exception ex) {
		throw new RuntimeException("Failed to scan script [" + script.sourceReader + "] for dependencies", ex);
	}
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 * @see com.heliosapm.streams.collector.cache.CacheEventListener#onValueAdded(java.lang.String, java.lang.Object)
 */
@Override
public void onValueAdded(final String key, final Object value) {
	final AtomicReferenceFieldUpdater<T, Object> updater = depUpdaters.get(key);
	if(updater!=null) {
		updater.set(script, value);
		script.getBinding().setVariable("_" + depFields.get(key).getName(), value);
		script.removePendingDependency(key);
		log.info("Dependent value [{}] initialized on [{}] from cache entry [{}]", value.getClass().getName(), scriptName, key);
	}
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 * @see com.heliosapm.streams.collector.cache.CacheEventListener#onValueRemoved(java.lang.String, java.lang.Object)
 */
@Override
public void onValueRemoved(final String key, final Object removedValue) {
	final AtomicReferenceFieldUpdater<T, Object> updater = depUpdaters.get(key);
	if(updater!=null) {
		script.addPendingDependency(key);
		updater.set(script, null);		
		script.getBinding().getVariables().remove("_" + depFields.get(key).getName());
		log.info("Dependent value removed from [{}] based on cleared cache entry [{}]", scriptName, key);
	}		
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 * @see com.heliosapm.streams.collector.cache.CacheEventListener#onValueReplaced(java.lang.String, java.lang.Object, java.lang.Object)
 */
@Override
public void onValueReplaced(final String key, final Object oldValue, final Object newValue) {
	final AtomicReferenceFieldUpdater<T, Object> updater = depUpdaters.get(key);
	if(updater!=null) {
		script.removePendingDependency(key);
		updater.set(script, newValue);
		script.getBinding().setVariable("_" + depFields.get(key).getName() , newValue);
		log.info("Dependent value [{}] replaced on [{}] from cache entry [{}]", newValue.getClass().getName(), scriptName, key);
	}				
}
 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; //导入方法依赖的package包/类
static private void testAtomicReferenceFieldUpdater() {
	System.out.println("AtomicTest.testAtomicReferenceFieldUpdater:");
	AtomicTest obj = new AtomicTest();
	AtomicReferenceFieldUpdater<AtomicTest, Integer> updater = AtomicReferenceFieldUpdater.newUpdater(AtomicTest.class, Integer.class, "value");
	System.out.println(updater.get(obj));
	updater.set(obj, 5);
	System.out.println(updater.get(obj));
	updater.compareAndSet(obj, 4, -4);
	System.out.println(updater.get(obj));
	updater.compareAndSet(obj, 5, -5);
	System.out.println(updater.get(obj));
}