原子类

第三章 原子类

3.1观察程序

概述：所谓的原子性是指在一次操作或多次操作，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要不所有的操作都不执行

观察程序

public class VolatileAtomicThread implements Runnable {
        // 定义一个int类型的遍历
        private int count = 0 ;
        @Override
        public void run() {
// 对该变量进行++操作，100次
            for(int x = 0 ; x < 100 ; x++) {
                count++ ;
                System.out.println("count =========>>>> " + count);
            }
        }
    }
    public class VolatileAtomicThreadDemo {
        public static void main(String[] args) {
// 创建VolatileAtomicThread对象
            VolatileAtomicThread volatileAtomicThread = new VolatileAtomicThread() ;
// 开启100个线程对count进行++操作
            for(int x = 0 ; x < 100 ; x++) {
                new Thread(volatileAtomicThread).start();
            }
        }

执行结果：不保证一定是10000

3.2 问题原理说明

以上问题主要是发生在count++操作上：

count++操作包含3个步骤：

• 从主内存中读取数据到工作内存

• 对工作内存中的数据进行++操作

• 将工作内存中的数据写回到主内存

  count++操作不是一个原子性操作，也就是说在某一个时刻对某一个操作的执行，有可能被其他的线程打 断。

1.假设此时x的值是100，线程A需要对改变量进行自增1的操作，首先它需要从主内存中读取变量x的值。由 于CPU的切换关系，此时CPU的执行权被切换到了 B线程。A线程就处于就绪状态，B线程处于运行状态

2.线程B也需要从主内存中读取x变量的值,由于线程A没有对x值做任何修改因此此时B读取到的数据还是100

3.线程B工作内存中x执行了+1操作，但是未刷新之主内存中

4.此时CPU的执行权切换到了A线程上，由于此时线程B没有将工作内存中的数据刷新到主内存，因此A线程 工作内存中的变量值还是100，没有失效。 A线程对工作内存中的数据进行了+1操作

5.线程B将101写入到主内存

6.线程A将101写入到主内存 虽然计算了2次，但是只对A进行了1次修改。

3.3. volatile原子性测试

// 定义一个int类型的变量
private volatile int count = 0 ;

小结：在多线程环境下，volatile关键字可以保证共享数据的可见性，但是并不能保证对数据操作的原子性 （在多线程环境下volatile修饰的变量也是线程不安全的）。 在多线程环境下，要保证数据的安全性，我们还需要使用锁机制。

**volatile的使用场景 **

开关控制

利用可见性特点，控制某一段代码执行或者关闭(比如今天课程的第一个案例)。

多个线程操作共享变量，但是是有一个线程对其进行写操作，其他的线程都是读

3.4问题解决

使用锁机制

我们可以给count++操作添加锁，那么count++操作就是临界区的代码，临界区只能有一个线程去执行，所 以count++就变成了原子操作。

    public class VolatileAtomicThread implements Runnable {
        // 定义一个int类型的变量
        private AtomicInteger atomicInteger = new AtomicInteger() ;
        @Override
        public void run() {
// 对该变量进行++操作，100次
            for(int x = 0 ; x < 100 ; x++) {
                int i = atomicInteger.getAndIncrement();
                System.out.println("count =========>>>> " + i);
            }
        }
    }

原子类CAS机制实现线程安全。

CAS的全称是： Compare And Swap(比较再交换); 是现代CPU广泛支持的一种对内存中的共享数据进行操作 的一种特殊指令。CAS可以将read-modify-check-write

转换为原子操作，这个原子操作直接由处理器保证。

CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。

举例：

1. 在内存地址V当中，存储着值为10的变量。

2. 此时线程1想要把变量的值增加1。对线程1来说，旧的预期值A=10，要修改的新值B=11。
   

3. 在线程1要提交更新之前，另一个线程2抢先一步，把内存地址V中的变量值率先更新成了11

4. 线程1开始提交更新，首先进行A和地址V的实际值比较（Compare），发现A不等于V的实际值，提交 失败。

5. 线程1重新获取内存地址V的当前值，并重新计算想要修改的新值。此时对线程1来说，A=11，B=12。 这个重新尝试的过程被称为自旋。

6. 这一次比较幸运，没有其他线程改变地址V的值。线程1进行Compare，发现A和地址V的实际值是相等 的。

7. 线程1进行SWAP，把地址V的值替换为B，也就是12。

CAS与Synchronized：乐观锁，悲观锁

CAS和Synchronized都可以保证多线程环境下共享数据的安全性。

那么他们两者有什么区别？

Synchronized是从悲观的角度出发（悲观锁）

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别 人想拿这个数据就会阻塞直到它拿到锁

**（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。**因此Synchronized 我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。性能较差！！

CAS是从乐观的角度出发:

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断 一下在此期间别人有没有去更新这个数据。

CAS这种机制我们也可以将其称之为乐观锁。综合性能较好！