并发编程的数据一致性问题

   声明:本站部分内容来自互联网,如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。

25

并发编程的数据一致性问题

    • CPU的优化之路
      • 缓存优化
      • MESI协议与可见性
      • 伪共享与缓存填充
      • 异步处理与指令重排
    • 解决CPU优化所带来的问题
      • JMM
      • volatile关键词
        • 可见性
        • 非原子性
        • 避免指令重排

CPU的优化之路

我们需要了解数据一次性问题,首先需要知道CPU为了更好的性能做了哪些优化。

缓存优化

要了解数据一致性问题产生的原因,我们首先要了解数据的传输路径,我们首先来看下以下这张图。


因为CPU的计算速率远大于IO等数据传输的速率,为了让CPU能持续稳定的007工作,使宝贵的CPU资源得到有效地利用,因此引入了缓存的概念,CPU与内存的交互也由此发生了改变。

MESI协议与可见性

在多核情况下,存在多个L1和L2缓存,那么如何保证线程之间以及线程与主存数据的一致性呢?
因此引入了MESI协议来解决数据的可见性问题。

在MESI协议中,每个Cache line有4个状态,可用2个bit表示,它们分别是:
M(Modified):这行数据有效,数据被修改了,和内存中的数据不一致,数据只存在于本Cache中;
E(Exclusive):这行数据有效,数据和内存中的数据一致,数据只存在于本Cache中;
S(Shared):这行数据有效,数据和内存中的数据一致,数据存在于很多Cache中;
I(Invalid):这行数据无效。

简单来说就是CacheA缓存了主存中的数据,状态为E,CacheB缓存了相同数据,此时CacheA和CacheB状态均修改为S,存在于不同CacheLine中,然后CacheA修改了数据,A变为M,B变为I。这样CPU就可以通过CacheLine的状态,来决定是删除缓存,还是直接读取什么的。

伪共享与缓存填充

使用MESI协议对缓存一致性进行优化以后又会出现新的问题,数据的伪共享问题。
我们的缓存行是以64字节为一行的,因为系统认为你读取了一个数据后,可能会在不久之后用到与之相邻的一些数据,因此一次读取64字节,由于MESI协议,会造成可能几个CPU同时修改同一块缓存内容,大量造成缓存失效,从而影响性能。
这样就出现了一个问题,b 和 a 完全不相干,每次却要因为 a 的更新需要从主内存重新读取,它被缓存未命中给拖慢了。


此时,为了优化缓存行的效率,从而引入了缓存填充的概念,使同一个变量独占一个缓存行,而其他位置使用一些不相干的数据进行填充,使其占满64字节,从而提高系统效率。

例如一个long类型数据占8字节,为了占满64字节,通常会在周围填充7个无意义的long类型数据使其占满64字节,即缓存填充。

public long p1, p2, p3, p4, p5, p6, p7; // cache line padding
private volatile long key = VALUE;
public long p8, p9, p10, p11, p12, p13, p14; // cache line padding

异步处理与指令重排

由于MESI协议,导致线程间通信的时候会有一段时间同步等待的交互时间,为了进一步压榨CPU剩余价值,会采取一种异步的方式来进行操作。

由于缓存刷新是异步操作,会导致CPU会在没接收到刷新命令之前进行一些其他命令,这种设计在提高性能的同时会导致另一个问题,指令重排,在单线程的时候,指令重排对程序运行最终结果没有任何影响,但是如果在多线程情况下,则会对结果产生影响。

解决CPU优化所带来的问题

由上文可知,CPU的性能优化导致了很多问题,比如缓存一致性问题,可见性问题,指令重排的问题。
那么如何有效的解决问题这些问题呢?

JMM

JMM(Java Memory Model的缩写)是一种java内存模型。它类似于缓存一致性协议,用于定义数据读写的规则。
JMM定义了线程工作内存和主内存的一种抽象关系,线程中的共享对象存在于主内存中,每个线程都有一块私有的本地内存。
解决共享对象可见性问题,即线程中修改数据立马同步到主线程中,其它线程复制时可以得到最新的数据:volilate和synchronize关键词。
JMM数据同步模型如下图。

volatile关键词

volatile关键字可以保持可见性,不能保证原子性,由于内存屏障,可以保证避免指令重排的现象产生!

可见性

两个线程,同时对单一对象进行操作时,均为从对象中复制一份,然后对复制的对象进行操作,然后合并。
可见性指的是当一个线程修改了这个变量的值,volatile 保证了新值能立即同步到主内存,保证修改的数据为最新的数据。

可见性测试

public class VisibilityDemo {private static int num = 0;public static void main(String[] args) throws InterruptedException {new Thread(()->{while(num == 0){}}).start();TimeUnit.SECONDS.sleep(1);num = 1;System.out.println(num);}
}

输出结果


此时线程陷入死循环,无法感知到main线程已经对数据进行了修改。

public class VisibilityDemo {private volatile static int num = 0;public static void main(String[] args) throws InterruptedException {new Thread(()->{while(num == 0){}}).start();TimeUnit.SECONDS.sleep(1);num = 1;System.out.println(num);}
}

输出结果


此时可以感知到main线程的变化,退出循环。

非原子性

原子性测试

public class AtomicityDemo {private volatile static int num = 0;public static void main(String[] args) throws InterruptedException {new Thread(()->{for (int i = 0; i < 50000; i++) {num++;}System.out.println("T1完成");},"T1").start();new Thread(()->{for (int i = 0; i < 50000; i++) {num++;}System.out.println("T2完成");},"T2").start();TimeUnit.SECONDS.sleep(1);System.out.println(num);}
}

输出结果


Num++不是原子操作,因为其可以分为:读取Num的值,将Num的值+1,写入最新的Num的值。
对于Num++;操作,线程1和线程2都执行一次,最后输出Num的值可能是:1或者2。

输出结果1的解释:当线程1执行Num++;语句时,先是读入Num的值为0,倘若此时让出CPU执行权,线程获得执行,线程2会重新从主内存中,读入Num的值还是0,然后线程2执行+1操作,最后把Num=1刷新到主内存中; 线程2执行完后,线程1已经开始执行,但之前已经读取的Num的值0,所以它还是在0的基础上执行+1操作,也就是还是等于1,并刷新到主内存中。所以最终的结果是1。

解决方案:使用CAS,通过自旋锁解决原子性问题

public class AtomicityDemo {private volatile static int num = 0;public static void main(String[] args) throws InterruptedException {AtomicInteger atomicInteger = new AtomicInteger(0);new Thread(()->{for (int i = 0; i < 50000; i++) {
//                num++;atomicInteger.getAndIncrement();}System.out.println("T1完成");},"T1").start();new Thread(()->{for (int i = 0; i < 50000; i++) {
//                num++;atomicInteger.getAndIncrement();}System.out.println("T2完成");},"T2").start();TimeUnit.SECONDS.sleep(1);
//        System.out.println(num);System.out.println(atomicInteger.get());}
}

输出结果

CAS应用场景

public class CASDemo {public static void main(String[] args) {AtomicInteger atomicInteger = new AtomicInteger(2020);
//        int andIncrement = atomicInteger.getAndIncrement();//        public final boolean compareAndSet(int expect, int update)
//        如果期望的值达到了,那么就更新,否则,就不更新,CAS 是 CPU 的并发原型System.out.println(atomicInteger.compareAndSet(2020, 2021));System.out.println(atomicInteger.get());System.out.println(atomicInteger.compareAndSet(2021, 2020));System.out.println(atomicInteger.get());System.out.println(atomicInteger.compareAndSet(2020, 6666));System.out.println(atomicInteger.get());}
}

输出结果

常见示例:自旋锁实现

CAS是一种有名的无锁算法。无锁编程,即不使用锁的情况下实现多线程之间的变量同步,也就是在没有线程被阻塞的情况下实现变量的同步
当第一个线程进入myLock时while条件为false,可以加锁,当第二个线程进入时while条件为true,进入循环,直到myUnLock执行结束,第二个线程跳出while循环,加锁成功。
自旋锁是指对一个内容无限循环,当达成条件的时候对其加锁,底层使用的是CAS。

自定义自旋锁

public class SpinLock {AtomicReference<Thread> atomicReference = new AtomicReference<>();public void myLock(){Thread thread = Thread.currentThread();while (!atomicReference.compareAndSet(null,thread)){}System.out.println(Thread.currentThread().getName() + "==> myLock");}public void myUnLock(){Thread thread = Thread.currentThread();atomicReference.compareAndSet(thread,null);System.out.println(Thread.currentThread().getName() + "==> myUnLock");}
}

自旋锁测试

public class SpinLockTest {public static void main(String[] args) throws InterruptedException {SpinLock lock = new SpinLock();new Thread(()->{lock.myLock();try {TimeUnit.SECONDS.sleep(5);} catch (Exception e) {e.printStackTrace();} finally {lock.myUnLock();}},"T1").start();TimeUnit.SECONDS.sleep(1);new Thread(()->{lock.myLock();try {TimeUnit.SECONDS.sleep(1);} catch (Exception e) {e.printStackTrace();} finally {lock.myUnLock();}},"T2").start();}
}

输出结果


线程T1占用时,线程T2会一直在循环中无法出来。只有当线程T1解锁,线程T2才会跳出循环,最终才会触发T2解锁。

常用示例:利用CAS解决ABA问题

CAS是java利用unsafe类通过对计算机底层的调用来进行数据的操作。底层实现为自旋锁。
CAS对数据修改时,可能会出现对数据修改两次,修改后值与之前相同的情况,因此会认定为未修改,此类问题被称为ABA问题,为了解决此类问题可以使用乐观锁,对每次记录新增一个记录,每次修改记录+1。

public class ABADemo {public static void main(String[] args) {AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);new Thread(()->{try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}int stamp = atomicStampedReference.getStamp();   //获得版本号System.out.println("a1 =>"+atomicStampedReference.getStamp());System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));System.out.println("a2 =>"+atomicStampedReference.getStamp());System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));System.out.println("a3 =>"+atomicStampedReference.getStamp());},"a").start();new Thread(()->{int stamp = atomicStampedReference.getStamp();   //获得版本号System.out.println("b1 =>"+stamp);try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(atomicStampedReference.compareAndSet(1, 6, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));System.out.println("b2 =>"+atomicStampedReference.getStamp());},"b").start();}
}

结果分析

避免指令重排

指令重排测试

public class OrderSort {static int a, b, x, y;static int num;public static void main(String[] args) throws InterruptedException {Set<String> stringSet = new HashSet<>();while (true) {a = 0;b = 0;x = 0;y = 0;Thread t1 = new Thread() {@Overridepublic void run() {x = 1;a = y;}};Thread t2 = new Thread() {@Overridepublic void run() {y = 1;b = x;}};t1.start();t2.start();t1.join();t2.join();stringSet.add("a:" + a + ",b:" + b);num++;System.out.println("第"+num+"次:"+stringSet);if (a == 0 && b == 0) {System.out.println("第"+num+"次结果为:a = 0,b = 0");break;}}}
}

测试结果

指令重排指的是,一段代码写出来的顺序可能为1=>2=>3=>4=>5,但是经过编译器以后的顺序并不一定严格按照这种顺序,可能在不影响结果的情况下改变为1=>3=>2=>4=>5。这种情况在单线程的情况下不会有任何问题,但是在多线程的情况下则会出现问题。而volatile关键词可以增加一个内存屏障(指令重排序时不能把后面的指令重排序到内存屏障之前的位置),只有一个CPU访问内存时,并不需要内存屏障。

常用示例:DCL懒汉式(双重检测锁模式)

//懒汉式单例模式
public class LazyMan {private LazyMan(){}private volatile static LazyMan lazyMan;//双重检测锁模式的懒汉式单例 DCL懒汉式public static LazyMan getInstance(){if (lazyMan == null){synchronized (LazyMan.class){if (lazyMan == null){lazyMan = new LazyMan();    //不是一个原子性操作}}}return lazyMan;}
}

此时当第一次创建对象时会进行加锁,但是由于指令重排可能会造成以下情况,所以需要对对象加上volatile关键词防止指令重排

/**
* 1、分配内存空间
* 2、执行构造方法,初始化对象
* 3、把这个对象指向这个空间
*
* 此时程序执行顺序可能为
* 1->2->3
* 1->3->2
* 若为1->3->2则可能发生以下情境
*
* A线程执行完1->3时,B线程执行,此时对象有指向的内存空间,但是并未初始化
* 当B进行判断时 lazyMan == null 为 false,则会直接返回未初始化的对象。
* 因此在声明对象时必须加上 volatile 关键词来防止指令重排
*/