【Java线程】线程安全三元素：原子性、可见性、有序性

谁践踏了优雅 2022-11-05 12:58 233阅读 0赞

### 目录 ###

*  定义
 *  原子性
 *   *  AtomicXxx
     *  AtomicStampedReference
 *  可见性
 *  有序性
 *  参考资料

# 定义 #

首先大家需要思考一下何为线程安全性呢？？？  
《**Java并发编程实战**》书中给出定义：当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步，这个类都能表现出正确的行为，那么这个类就是线程安全的。

对于线程安全性主要从以下几个方面出发：**原子性、有序性、可见性**。

**原子性**：提供互斥访问，同一时刻只能有一个线程对数据进行操作；  
例如：**atomicXXX类，synchronized**关键字的应用。

**有序性**：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序；例如，**happens-before**原则。

**可见性**：一个线程对主内存的修改可以及时地被其他线程看到；例如：**synchronized,volatile**。

# 原子性 #

## AtomicXxx ##

谈起原子性肯定离不开众所周知的**Atomic包**，JDK里面提供了很多atomic类，AtomicInteger,AtomicLong,AtomicBoolean等等。

以AtomicInteger为例：

class AtomicIntegerExample { 
        private static final Logger log = LoggerFactory.getLogger(AtomicIntegerExample.class);
        // 请求总数
        public static int requestTotal = 500;
        // 并发执行的线程数
        public static int threadTotal = 20;
    
        public static AtomicInteger count = new AtomicInteger(0);
    
        public static void main(String[] args) throws Exception { 
            ExecutorService executorService = Executors.newCachedThreadPool();//获取线程池
            final Semaphore semaphore = new Semaphore(threadTotal);//定义信号量
            final CountDownLatch countDownLatch = new CountDownLatch(requestTotal);
            for (int i = 0; i < requestTotal ; i++) { 
                executorService.execute(() -> { 
                    try { 
                        semaphore.acquire();
                        add();
                        semaphore.release();
                    } catch (Exception e) { 
                        log.error("exception", e);
                    }
                    countDownLatch.countDown();
                });
            }
            countDownLatch.await();
            executorService.shutdown();
            log.info("count:{}", count.get());
        }
    
        private static void add() { 
            count.incrementAndGet();
        }
    }

跟着这个Demo，试着debuge一下，看下底层如何实现的？？？  
关键方法：**incrementAndGet（）**

/** * Atomically increments by one the current value. * * @return the updated value */
        public final int incrementAndGet() { 
            return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
        }

AtomicInteger中的incrementAndGet方法就是乐观锁的一个实现，使用自旋（循环检测更新）的方式来更新内存中的值并通过底层CPU执行来保证是更新操作是原子操作。

使用自旋锁机制便会造成何种问题呢？？？  
如果长时间自旋不成功，则会给CPU带来非常大的执行开销。

随之我们跟进**getAndAddInt**方法，即魔法类UnSafe，关于此类，后期小编抽时间也会整理出一篇文章出来，敬请期待吧，，，哈哈～

public final int getAndAddInt(Object var1, long var2, int var4) { 
           int var5;
           do { 
           //获取当前对象的值
               var5 = this.getIntVolatile(var1, var2);
           } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
           return var5;
       }

大家先分析一下这个方法的代码结构：do-while(),然后再理解执行逻辑。

**首先通过调用getIntVolatile()方法，使用对象的引用与值的偏移量得到当前值，然后调用compareAndSwapInt检测如果obj内的value和expect相等，就证明没有其他线程改变过这个变量，那么就更新它为update，如果这一步的CAS没有成功，那就采用自旋的方式继续进行CAS操作**。

对于上面的方法参数需要特殊解释一下，要不然真的会很懵逼：  
compareAndSwapInt()希望达到的目标是对于**var1对象**，如果**当前的值var2**和**底层的值var5**相等，那么把它更新成**后面的值（var5+var4）**.

希望大家能够理解清楚，更重要的是小编不要理解错误了，如果存在问题，希望大佬私信不当之处，及时改正。

原子性底层实现核心思想是：**CAS**，但是CAS中存在**ABA问题**。

**compareAndSet**是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

**何为ABA呢？？？**  
如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。这就是CAS的ABA问题。

那面对ABA问题，大家是想着如何解决呢？？？可以思考一下数据库中乐观锁机制，**版本号**。  
故JDK引出AtomicStampedReference…

## AtomicStampedReference ##

先看下这个类的方法，大家要注意翻译注释，理解各个参数的含义

/** * Atomically sets the value of both the reference and stamp * to the given update values if the * current reference is {@code ==} to the expected reference * and the current stamp is equal to the expected stamp. * * @param expectedReference the expected value of the reference * @param newReference the new value for the reference * @param expectedStamp the expected value of the stamp * @param newStamp the new value for the stamp * @return {@code true} if successful */
        public boolean compareAndSet(V   expectedReference,
                                     V   newReference,
                                     int expectedStamp,
                                     int newStamp) { 
            Pair<V> current = pair;
            return
                expectedReference == current.reference &&
                expectedStamp == current.stamp &&
                ((newReference == current.reference &&
                  newStamp == current.stamp) ||
                 casPair(current, Pair.of(newReference, newStamp)));
        }

**此方法会检查当前引用是否等于预期引用，并且当前标志是否等于预期标志；  
如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。**

# 可见性 #

简单划下重点：  
**什么是线程间的可见性？**  
一个线程对共享变量值的修改，能够及时的被其他线程看到。

**什么是共享变量？**  
如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。

**什么是java内存模型？（Java Memory Model，简称JMM）**

JMM描述了java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将变量存储到内存和从内存中读取出变量这样的底层细节。  
规则1：  
1>所有的变量都存储在主内存中  
2>每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本（主内存中该变量的一份拷贝）

规则2：  
1>线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接从主内存中读写  
2>不同线程之间无法直接访问其他线程工作内存中的变量，线程间变量的传递需要通过主内存来完成。  
对于线程可见性大家更多层面是基于Volatile的应用，请大家移步我的另一篇文章[【Java线程】深入理解Volatile关键字和使用][Java_Volatile]

# 有序性 #

**有序性是指程序在执行的时候，程序的代码执行顺序和语句的顺序是一致的**。  
为什么会出现不一致的情况呢？—重排序

在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。  
对于有序性，小编之前读过周志明的《深入理解Java虚拟机》书中是这样介绍有序性的：  
**Happends-Before原则**

1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；
    2.锁定规则：一个unLock操作先行发生于后面对同一个锁lock操作；
    3.volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；
    4.传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；
    5.线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
    6.线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
    7.线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；
    8.对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

对于线程的可见性和有序性的理解，需要建立Java内存模型在基础上理解和思考，虽然理解起来有点抽象，每次读到系列文章，都是能收获不同的知识点，书读百遍其义自见，哈哈，，，继续加油吧！！！向每一位正在努力的程序员致敬！！！

# 参考资料 #

《Java高并发编程实战》  
《Java并发编程》  
[多线程安全性和Java中的锁][Java]

[Java_Volatile]: https://blog.csdn.net/xuan_lu/article/details/111403601?spm=1001.2014.3001.5502
[Java]: https://juejin.cn/post/6844903782103384072