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

《Java并发编程实战》书中给出定义：当多个线程访问某个类时，无论运行时环境采用何种调度方式或者这些线程将如何交替执行，而且在调用代码中不须要任何额外的同步，这个类都能表现出正确的行为，那么这个类就是线程安全的。程序员

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

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

有序性：一个线程观察其余线程中的指令执行顺序，因为指令重排序，该观察结果通常杂乱无序；例如，happens-before原则。安全

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

原子性

AtomicXxx 多线程

谈起原子性确定离不开众所周知的Atomic包，JDK里面提供了不少atomic类，AtomicInteger,AtomicLong,AtomicBoolean等等。并发

以AtomicInteger为例： app

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（）oop

/**
     * 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>不一样线程之间没法直接访问其余线程工做内存中的变量，线程间变量的传递须要经过主内存来完成。

有序性

有序性是指程序在执行的时候，程序的代码执行顺序和语句的顺序是一致的。

为何会出现不一致的状况呢？—重排序

在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内存模型在基础上理解和思考，虽然理解起来有点抽象，每次读到系列文章，都是能收获不一样的知识点，书读百遍其义自见，哈哈，，，继续加油吧！！！向每一位正在努力的程序员致敬！！！

出处：blog.csdn.net/xuan\_lu/ar…?

看完四件事❤️

若是你以为这篇内容对你还蛮有帮助，我想邀请你帮我三个小忙：

点赞，转发，有大家的『点赞和评论』，才是我创造的动力。
关注公众号『 JavaAC 』，不按期分享原创知识。
同时能够期待后续文章ing🚀
.关注后扫码便可获取学习资料包

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

目录

原子性

AtomicStampedReference

有序性

看完四件事❤️