CAS 原子操作

package org.dance.day3;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 使用原子类int类型
 * @author ZYGisComputer
 */
public class UseAtomicInt {

    static AtomicInteger atomicInteger = new AtomicInteger(10);

    public static void main(String[] args) {
        // 10->11 10先去再增加
        System.out.println(atomicInteger.getAndIncrement());
        // 11->12 12先增加再取
        System.out.println(atomicInteger.incrementAndGet());
        // 获取
        System.out.println(atomicInteger.get());
    }

}

10
12
12

package org.dance.day3;

import java.util.concurrent.atomic.AtomicIntegerArray;

/**
 * 使用原子类int[]
 * @author ZYGisComputer
 */
public class UseAtomicIntegerArray {

    static int[] values = new int[]{1,2};

    static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(values);

    public static void main(String[] args) {
        //改变的第一个参数是 数组的下标,第二个是新值
        atomicIntegerArray.getAndSet(0,3);
        // 获取原子数组类中的下标为0的值
        System.out.println(atomicIntegerArray.get(0));
        // 获取源数组中下标为0的值
        System.out.println(values[0]);
    }

}

3
1

/**
     * Creates a new AtomicIntegerArray with the same length as, and
     * all elements copied from, the given array.
     *
     * @param array the array to copy elements from
     * @throws NullPointerException if array is null
     */
    public AtomicIntegerArray(int[] array) {
        // Visibility guaranteed by final field guarantees
        this.array = array.clone();
    }

package org.dance.day3;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 使用原子类引用类型
 * @author ZYGisComputer
 */
public class UseAtomicReference {

    static AtomicReference<UserInfo> atomicReference = new AtomicReference<>();

    public static void main(String[] args) {

        UserInfo src = new UserInfo("彼岸舞",18);

        // 使用原子引用类包装一下
        atomicReference.set(src);

        UserInfo target = new UserInfo("彼岸花",19);

        // 这里就是CAS改变了,这个应用类就好像一个容器也就是内存V,而src就是原值A,target就是新值B
        // 期望原值是src,如果是的话,改变为target,否则不变
        atomicReference.compareAndSet(src,target);

        System.out.println(atomicReference.get());

        System.out.println(src);

    }

    static class UserInfo{
        private String name;
        private int age;

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

        public UserInfo() {
        }

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

}

UserInfo{name=‘彼岸花‘, age=19}
UserInfo{name=‘彼岸舞‘, age=18}

package org.dance.day3;

import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * 使用版本号解决ABA问题
 * @author ZYGisComputer
 */
public class UseAtomicStampedReference {

    /**
     * 构造参数地第一个是默认值,第二个就是版本号
     */
    static AtomicStampedReference<String> atomicStampedReference = new AtomicStampedReference<>("src",0);

    public static void main(String[] args) throws InterruptedException {

        // 获取初始版本号
        final int oldStamp = atomicStampedReference.getStamp();

        // 获取初始值
        final String oldValue = atomicStampedReference.getReference();

        System.out.println("oldValue:"+oldValue+" oldStamp:"+oldStamp);

        Thread success = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+",当前变量值:"+oldValue+"当前版本号:"+oldStamp);
                // 变更值和版本号
                /**
                 * 第一个参数:期望值
                 * 第二个参数:新值
                 * 第三个参数:期望版本号
                 * 第四个参数:新版本号
                 */
                boolean b = atomicStampedReference.compareAndSet(oldValue, oldValue + "java", oldStamp, oldStamp + 1);
                System.out.println(b);
            }
        });

        Thread error = new Thread(new Runnable() {
            @Override
            public void run() {
                // 获取原值
                String sz = atomicStampedReference.getReference();
                int stamp = atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread().getName()+",当前变量值:"+sz+"当前版本号:"+stamp);
                boolean b = atomicStampedReference.compareAndSet(oldValue, oldValue + "C", oldStamp, oldStamp + 1);
                System.out.println(b);
            }
        });

        success.start();
        success.join();
        error.start();
        error.join();
        System.out.println(atomicStampedReference.getReference()+":"+atomicStampedReference.getStamp());
    }

}

oldValue:src oldStamp:0
Thread-0,当前变量值:src当前版本号:0
true
Thread-1,当前变量值:srcjava当前版本号:1
false
srcjava:1