Java referencia AtomicReference clase de tipo de uso operación atómica

/**
 * 类说明：演示引用类型的原子操作类
 */
public class UseAtomicReference {
    static AtomicReference<UserInfo> atomicUserRef;

    public static void main(String[] args) {
        UserInfo user = new UserInfo("Mark", 15);//要修改的实体的实例
        atomicUserRef = new AtomicReference(user);
        UserInfo updateUser = new UserInfo("Bill", 17);
        boolean a = atomicUserRef.compareAndSet(user, updateUser);
        System.out.println(a);
        System.out.println(atomicUserRef.get());
        System.out.println(user);
    }

    //定义一个实体类
    static class UserInfo {
        private volatile String name;
        private int age;

        public UserInfo(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

}

nota:

atomicUserRef.compareAndSet (usuario, updateUser); el objeto es cambiar la ruta original de la referencia, pero el valor en sí no cambia

 nuevo AtomicReference (usuario); encapsular el objeto, a fin de convertirse en una operación atómica

AtomicStampedReference

crear

AtomicStampedReference <String> ASR = new AtomicStampedReference ( "djy", 0);

El código fuente para:

nota:

Aquí se puede ver el llamado ABA AtomicStampedReference capaz de resolver el problema, un muy simple control de versiones

 ABA resolución de problemas

/**
 * 类说明：演示带版本戳的原子操作类
 */
public class UseAtomicStampedReference {
    static AtomicStampedReference<String> asr
            = new AtomicStampedReference("djy", 0);

    public static void main(String[] args) throws InterruptedException {
        //拿到当前的版本号(旧)
        final int oldStamp = asr.getStamp();
        final String oldReference = asr.getReference();
        System.out.println(oldReference + "============" + oldStamp);

        Thread rightStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                asr.compareAndSet(oldReference, "java", oldStamp, oldStamp + 1);
            }
        });

        Thread errorStampThread = new Thread(new Runnable() {
            @Override
            public void run() {
                String reference = asr.getReference();
                int stamp = asr.getStamp();
                asr.compareAndSet(reference, "C++", stamp, stamp + 1);
            }
        });
        rightStampThread.start();
        //让线程充分运行完毕
        rightStampThread.join();
        errorStampThread.start();
        errorStampThread.join();

        System.out.println(asr.getReference() + "============" + asr.getStamp());
    }
}

AtomicMarkableReference

Uso y coherente AtomicStampedReference

La diferencia AtomicMarkableReference y AtomicStampedReference?

AtomicStampedReference

Constructor initialStamp (timestamp) para identificar de forma única una variable de referencia, en la estructura interna, una instancia un par de objetos, Par de grabación de objeto de información de marca de tiempo y las referencias a objetos utilizados int como un sello de tiempo, cuando en el uso real, a la única garantía de una marca de tiempo (generalmente de crecimiento), si la marca de tiempo si se repite, aparecerá ABA problema.

El AtomicStampedReference cada variable de referencia se ponen pair.stamp este sello de tiempo, por lo que se puede resolver el problema de la CAS en la ABA.

/**
 * Creates a new {@code AtomicStampedReference} with the given
 * initial values.
 *
 * @param initialRef the initial reference
 * @param initialStamp the initial stamp
 */
public AtomicStampedReference(V initialRef, int initialStamp) {
    pair = Pair.of(initialRef, initialStamp);
}

AtomicMarkableReference

AtomicStampedReference conocimientos, las variables de referencia se han cambiado varias veces a mitad de camino. A veces, no nos importa acerca de las variables de referencia cambiaron varias veces, pero simplemente preocupados por si o no cambiado , por lo que AtomicMarkableReference.

La única diferencia AtomicMarkableReference ya no se utiliza de referencia identidad int, pero el uso de la variable booleana - Indica si se cambia la variable de referencia.

constructor

/**
 * Creates a new {@code AtomicMarkableReference} with the given
 * initial values.
 *
 * @param initialRef the initial reference
 * @param initialMark the initial mark
 */
public AtomicMarkableReference(V initialRef, boolean initialMark) {
    pair = Pair.of(initialRef, initialMark);
}