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

定义

首先大家需要思考一下何为线程安全性呢???
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内存模型中,允许编译器和处理器对指令进行重排序,但是重排序过程不会影响到单线程程序的执行,却会影响到多线程并发执行的正确性。
对于有序性,小编之前读过周志明的《深入理解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中的锁

版权声明:玥玥 发表于 2021-03-09 13:12:54。
转载请注明:【Java线程】线程安全三元素:原子性、可见性、有序性 | 女黑客导航