线程安全性

github学习笔记传送门

  • df: 当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么称这个类是线程安全的
  • 原子性：提供了互斥访问，同一时刻只能有一个线程来对他进行操作
  • 可见性：一个线程对主内存的修改可以及时的被线程观察到
  • 有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序的存在，该观察结果一般杂乱无序
  1. 原子性 -Atomic包
  • AtomicXXX: CAS,Unsafe.compareAndSwapInt
// Java底层包、非Java实现
   public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

   // 拿当前对象的值和底层的值进行对比，如果相等才进行操作，如果不同则一直执行，直到相同
   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;
      }
  • AtomicLong,LongAdder
  • LongAdder: AtomicLong的实现原理是：利用底层操作系统的CAS来保证原子性，在一个死循环内不断执行CAS操作，直到操作成功。不过，CAS操作的一个问题是在并发量比较大的时候，可能很多次的执行CAS操作都不成功，这样性能就受到较大影响。
    在ConcurrentHashMap中，对Map分割成多个segment，这样多个Segment的操作就可以并行执行，从而可以提高性能。在JDK8中，LongAdder与ConcurrentHashMap类似，将内部操作数据value分离成一个Cell数组，每个线程访问时，通过Hash等算法映射到其中一个Cell上。
    计算最终的数据结果，则是各个Cell数组的累计求和。
  • 缺点：在统计时如果有并发可能会导致统计的数据有所误差
  • AtomicReference,AtomicReferenceFieldUpdater
  • AtomicExample5
  • AtomicStampReference: CAS的ABA问题
  • ABA问题：在进行CAS操作时，线程将A改为B又改回A,每次修改时改变版本号
  1. 原子性-synchronized
  • 修饰代码块：大括号括起来的代码，作用于调用的对象
  • 修饰方法：整个方法，作用于调用的对象
  • 修饰静态方法：整个静态方法，作用于所有对象
  • 修饰类：括号括起来的部分，作用于整个对象
  • 与lock的对比
  • synchronized：不可中断锁，适合竞争不激烈，可读性好
  • Lock：可中断锁，多样化同步，竞争激烈时能维持常态
  • Atomic：竞争激烈时能维持常态，比Lock性能要好；但只能同步一个值
  1. 可见性

导致共享变量在线程间不可见的原因

  • 线程交叉执行
  • 重排序结合线程交叉执行
  • 共享变量更新后的值没有在工作内存与主存间及时更新
  1. JVM关于synchronized的两条规定
  2. 线程解锁前，必须把共享变量的最新值刷新到主内存
  3. 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（加锁和解锁是同一把锁）
  1. 可见性 -volatile

通过加入内存屏障和禁止重排序优化来实现

  1. 对volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的共享变量值刷新到主内存
  2. 对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量
  3. volatile使用 – 作为标记量使用
volatile boolean inited = false;

// 线程1
context = loadContext();
inited = true;

// 线程2
while(!inited){
 sleep();
}
doSomethingWithConfig(context);
  1. 有序性

Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序的过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性

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