原子操作CAS，原子性操作类

原子操作CAS

 

CAS的原理

CAS(Compare And Swap)，指令级别保证这是一个原子操作

三个运算符：  一个内存地址V，一个期望的值A，一个新值B

基本思路：如果地址V上的值和期望的值A相等，就给地址V赋给新值B，如果不是，不做任何操作。

 synchronized和CAS（悲观锁和乐观锁是抽象的）

• synchronized是悲观锁，这种线程一旦得到锁，其他需要锁的线程就挂起的情况就是悲观锁。
• CAS操作的就是乐观锁，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。

sychronized

首先Synchronized是确保线程安全的，但是在性能上却不是最优的。Synchronized关键字会让没有得到锁资源的线程进入BLOCKED状态，而后在争夺到锁资源后恢复为RUNNABLE状态，这个过程中涉及到操作系统用户模式和内核模式的转换，代价比较高。 尽管Java1.6为Synchronized做了优化，增加了从偏向锁到轻量级锁再到重量级锁的过度，但是在最终转变为重量级锁之后，性能仍然较低。 

原子性操作类

jdk提供了java.util.concurrent.atomic包，并且这些类都是使用Unsafe实现的包装类。

1.原子更新基本类型

atomic提供了3个类用于原子更新基本类型：分别是AtomicInteger原子更新整形，AtomicLong原子更新长整形，AtomicBoolean原子更新bool值。都是大同小异，所以AtomicInteger为例说明。

AtomicInteger常用方法：（这里我找到一个大概的规律，一般get在前，add、set、Increment等等在后，就是先返回，再处理；反之add、set、Increment等等再前的，就是先处理，再返回）

　1.int addAndGet(int delta)：以原子的方式将输入的值与实例中的值相加，并把结果返回

　2.boolean compareAndSet(int expect, int update)：如果输入值等于预期值，以原子的方式将该值设置为输入的值

　3.final int getAndIncrement()：以原子的方式将当前值加1，并返回加1之前的值

　4.void lazySet(int newValue)：最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

　5.int getAndSet(int newValue)：以原子的方式将当前值设置为newValue,并返回设置之前的旧值

public class UseAtomicInt {
	
	static AtomicInteger ai = new AtomicInteger(10);
	
    public static void main(String[] args) {
    	System.out.println(ai.getAndIncrement());//10--->out--->11 先返回再增加
    	System.out.println(ai.incrementAndGet());//11--->12--->out  先增加再返回
		System.out.println(ai.addAndGet(1));//12+1--->13--->out  先增加再返回
		System.out.println(ai.incrementAndGet());//13--->14--->out  先增加再返回
		System.out.println(ai.getAndSet(20));//14--->out--->20  先返回再相加
		System.out.println(ai.get());
    }
}

10
12
13
14
14
20

 

2.原子更新数组 

atomic里提供了三个类用于原子更新数组里面的元素，分别是：AtomicIntegerArray：原子更新整形数组里的元素，AtomicLongArray：原子更新长整形数组里的元素，AtomicReferenceArray：原子更新引用数组里的元素

AtomicIntegerArray主要提供了以原子方式更新数组里的整数，常见方法如下：

　　int addAndGet(int i, int delta)：以原子的方式将输入值与数组中索引为i的元素相加

　　boolean compareAndSet(int i, int expect, int update)：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

public class AtomicArray {
    static int[] value = new int[] { 1, 2 };
    
    static AtomicIntegerArray ai = new AtomicIntegerArray(value);
    
    public static void main(String[] args) {
    	ai.getAndSet(0, 3);// 在0角标，添加数据为3
        ai.addAndGet(0,2);// 在0角标的数据上加2

    	System.out.println(ai.get(0));// 5
    	System.out.println(value[0]); // 1

    }
}

5
1

 

 3.原子更新引用

原子引用类型atomic包主要提供了以下几个类：AtomicReference：原子更新引用类型，AtomicReferenceFieldUpdater：原子更新引用类型里的字段

AtomicReference为例：

public class UseAtomicReference {
	
	static AtomicReference<UserInfo> userRef = new AtomicReference<UserInfo>();
	
    public static void main(String[] args) {
        UserInfo user = new UserInfo("Mark", 15);//要修改的实体的实例
        userRef.set(user);
        
        UserInfo updateUser = new UserInfo("Bill", 17);//要变化的新实例
        userRef.compareAndSet(user, updateUser);// updateUser覆盖user
        System.out.println(userRef.get().getName());
        System.out.println(userRef.get().getAge());
        System.out.println(user.getName());
        System.out.println(user.getAge());        
    }
    
    //定义一个实体类
    static class UserInfo {
        private 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;
        }
    }

}

Bill
17
Mark
15

4.原子更新属性

　如果需要原子更新某个对象的某个字段，就需要使用原子更新属性的相关类，atomic中提供了一下几个类用于原子更新属性：

　　AtomicIntegerFieldUpdater：原子更新整形属性的更新器

　　AtomicLongFieldUpdater：原子更新长整形的更新器

　　AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的ABA问题。

AtomicStampedReference为例：

public class UseAtomicStampedReference {
	
	static AtomicStampedReference<String> asr = 
			new AtomicStampedReference<>("Mark",0);
	

    public static void main(String[] args) throws InterruptedException {
    	final int oldStamp = asr.getStamp();//那初始的版本号
    	final String oldReferenc = asr.getReference();
    	
    	System.out.println(oldReferenc+"==========="+oldStamp);
    	
    	Thread rightStampThread = new Thread(new Runnable() {

			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()
						+"当前变量值："+oldReferenc+"当前版本戳："+oldStamp+"-"
						+asr.compareAndSet(oldReferenc, oldReferenc+"Java",
								oldStamp, oldStamp+1));
				
			}
    		
    	});
    	
    	Thread errorStampThread = new Thread(new Runnable() {

			@Override
			public void run() {
				String reference = asr.getReference();
				System.out.println(Thread.currentThread().getName()
						+"当前变量值："+reference+"当前版本戳："+asr.getStamp()+"-"
						+asr.compareAndSet(reference, reference+"C",
								oldStamp, oldStamp+1));

			}

    	});
    	
    	rightStampThread.start();
    	rightStampThread.join();
    	errorStampThread.start();
    	errorStampThread.join();
    	System.out.println(asr.getReference()+"==========="+asr.getStamp());
    	
    }
}

Mark===========0
Thread-0当前变量值：Mark当前版本戳：0-true
Thread-1当前变量值：MarkJava当前版本戳：1-false
MarkJava===========1

 

模拟AtomicInteger的类实现了线程安全的：get方法和compareAndSet()方法,自行实现它的递增方法

public class HalfAtomicInt {
    private AtomicInteger atomicI = new AtomicInteger(0);

    public void increament() {
        for (;;) { // 自旋
            int i = atomicI.get();
            boolean suc = atomicI.compareAndSet(i, ++i);// 直到compare成功
            if (suc) {
                break;
            }
        }
    }
    
    public int getCount() {
    	return atomicI.get();
    }

}

 

CAS的缺点：

1.CPU开销较大
在并发量比较高的情况下，如果许多线程反复尝试更新某一个变量，却又一直更新不成功，循环往复，会给CPU带来很大的压力。

2.不能保证代码块的原子性
CAS机制所保证的只是一个变量的原子性操作，而不能保证整个代码块的原子性。比如需要保证3个变量共同进行原子性的更新，就不得不使用Synchronized了。

CAS的ABA问题：

当我们要对Value进行操作的时候，要先拿到Value这个值，然后在操作一遍，但是最终得到的全新的Value和原来的Value一样。这样就是我们的ABA，A经过B操作后得到的还是A。那么这就会导致CAS有一个漏洞。判断全新Value和原来的Value相等，也不能确定原来的Value没有被修改。
      那么怎么解决呢？

JDK中的AtomicStampedReference这个类给我们每个变量的状态值都配备了一个时间戳，也就是每个变量在比较值相等的同时，也会比较时间戳，这样就避免了ABA问题的产生。