原子变量与CAS算法

原子变量与CAS算法

一、什么是原子变量？

　　原子变量简介

　　一般我们在程序中修改一个代码的值会分为3步：读取==》 修改 ==》 回写。在允许多线程的程序中而对于某一资源我们只希望有一个线程操作它，我会想使用全局变量去作为标记变量。两个线程A、B，当A读取完该全局变量后正在修改它的值，而这时B进程正在读取该全局变量，对于B进程而言此全局变量的值和A进程是一样，这样A、B都可以正常进行，就与我们的意愿相违了，所以我们会想是不是可以定义一个变量，将对一个变量值得读取修改回写变成一个不可打断的操作，于是我们就有了原子变量。

　　jdk1.5之后引入了java.util.concurrent.atomic工具包，它封装了许多基本数据类型对应的原子变量类，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可将volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。

　　java.util.concurrent.atomic 包下提供的一些原子操作的常用类有:
　　AtomicBoolean 、AtomicInteger 、AtomicLong 、AtomicReference
　　AtomicIntegerArray 、AtomicLongArray
　　AtomicMarkableReference
　　AtomicReferenceArray
　　AtomicStampedReference

　　类AtomicBoolean、AtomicInteger、AtomicLong 和AtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。

　　类AtomicIntegerArray、AtomicLongArray 和AtomicReferenceArray 进一步扩展了原子操作，对这些类型的数组提供了支持。这些类在为其数组元素提供volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。

　　核心方法：boolean compareAndSet(expectedValue, updateValue)即下面要提到的CAS算法相关

　　代码分析

package me.concurrent.atomic;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 一、i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”
 *           int i = 10;
 *           i = i++; //10
 * 
 *           int temp = i;
 *           i = i + 1;
 *           i = temp;
 * 
 * 二、原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
 * 1. volatile 保证内存可见性
 * 2. CAS（Compare-And-Swap） 算法保证数据变量的原子性
 *     CAS 算法是硬件对于并发操作的支持
 *     CAS 包含了三个操作数：
 *     ①内存值  V
 *     ②预估值  A （当前线程上一次修改的最新旧值）
 *     ③更新值  B
 *     当且仅当 V == A 时， V = B; 否则，不会执行任何操作。
 */
public class TestAtomicDemo {

    public static void main(String[] args) {
    AtomicDemo ad = new AtomicDemo();

    for (int i = 0; i < 10; i++) {
        new Thread(ad).start();
    }
    }

}

class AtomicDemo implements Runnable {

    // private volatile int serialNumber = 0;

    private AtomicInteger serialNumber = new AtomicInteger(0);

    @Override
    public void run() {

    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
    }

    System.out.println(getSerialNumber());
    }

    public int getSerialNumber() {
    return serialNumber.getAndIncrement();
    }

}

二、什么是CAS

　　CAS简介

　　CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问。

　　CAS 是一种无锁的非阻塞算法的实现。

　　CAS 包含了3 个操作数：
　　①需要读写的内存值V
　　②进行比较的值A（当前线程上一次修改后的旧值）
　　③拟写入的新值B

　　当且仅当V 的值等于A 时，CAS 通过原子方式用新值B 来更新V 的值，否则不会执行任何操作。

 　　代码分析

package me.concurrent.atomic;

/**
 * 模拟 CAS 算法
 * CAS算法一般比锁的效率要高，如果当这一次不成功的时候也就是V != A时，他不会造成阻塞，也就是不会放弃CPU给他的执行权，它可以立即再去尝试再去更新
 * CAS算法的缺点，一旦更新值失败了之后，它会再次尝试
 * CAS算法如果多个线程对共享变量修改时，有且只有一个会成功，其它的都会失败
 */
public class TestCompareAndSwap {

    public static void main(String[] args) {
    final CompareAndSwap cas = new CompareAndSwap();
    for (int i = 0; i < 10; i++) {
        new Thread(new Runnable() {
        @Override
        public void run() {
            int expectedValue = cas.get();
            boolean b = cas.compareAndSet(expectedValue, (int) (Math.random() * 101));
            System.out.println(b);
        }
        }).start();
    }
    }
}

class CompareAndSwap {
    private int value;

    /**
     * 获取内存值
     */
    public synchronized int get() {
    return value;
    }

    /**
     * 比较
     * 
     * @param expectedValue 预估值
     * @param newValue 更新值
     * @return
     */
    public synchronized int compareAndSwap(int expectedValue, int newValue) {
    int oldValue = value;

    if (oldValue == expectedValue) {
        this.value = newValue;
    }
    return oldValue;
    }

    /**
     * 设置
     * 
     * @param expectedValue 预估值
     * @param newValue 更新值
     * @return
     */
    public synchronized boolean compareAndSet(int expectedValue, int newValue) {
    return expectedValue == compareAndSwap(expectedValue, newValue);
    }
}

如果，您对我的这篇博文有什么疑问，欢迎评论区留言，大家互相讨论学习。
如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】。
如果，您希望更容易地发现我的新博客，不妨点击一下左下角的【关注我】。
如果，您对我的博文感兴趣，可以关注我的后续博客，我是【AlbertRui】。

转载请注明出处和链接地址，欢迎转载，谢谢！