锁的相关内存语义,java内存模型,线程基础

安全性、活跃性、性能相关

  • 竞态条件

竞态条件,指的是程序的执行结果依赖线程执行的顺序或者程序的执行依赖于某个状态变量,当某个线程发现状态变量满足执行条件后,开始执行操作;可是就在这个线程执行操作的时候,其他线程同时修改了状态变量,导致状态变量不满足执行条件了
解决措施:通过锁去进行条件的互斥

  • 死锁、活锁、饥饿

死锁:因争夺资源而互相等待,导致操作无法执行下去
活锁:不会因为阻塞,但是也执行不下去,如相互谦让,同时放弃,又重试竞争,一直循环
饥饿:持有锁的线程执行时间太长或者优先级低的线程一直无法执行

  • 总结

    • 安全性问题的源头:原子性;可见性;有序性
    • 安全性问题出现的根本原因:数据竞争(多个线程读写共享数据);竞态条件(程序的执行结果依赖线程执行的顺序)
    • 活跃性问题的三种情况:死锁;活锁;饥饿
    • 性能问题的关键指标 吞吐量、延迟和并发量。
      性能问题的几种思路:无锁方案(TLS、COW、乐观锁);减少锁粒度

      • 吞吐量:指的是单位时间内能处理的请求数量。吞吐量越高,说明性能越好。
      • 延迟:指的是从发出请求到收到响应的时间。延迟越小,说明性能越好。
      • 并发量:指的是能同时处理的请求数量,一般来说随着并发量的增加、延迟也会增加。所以延迟这个指标,一般都会是基于并发量来说的。例如并发量是 1000 的时候,延迟是 50 毫秒
    • 锁的最佳实践

      • 永远只在更新对象的成员变量时加锁
      • 永远只在访问可变的成员变量时加锁
      • 永远不在调用其他对象的方法时加锁(因为其他对象的方法可能存在长时间的操作,比如IO,sleep)

线程状态

  • java中的线程状态

    • NEW(初始化状态)
      指的是线程已经被创建,但是还不允许分配 CPU 执行,真正的线程还没创建
    • RUNNABLE(可运行 / 运行状态)
      可以分配CPU使用权
    • BLOCKED(阻塞状态)
      没有CPU使用权,同时 阻塞态的线程不响应中断 --- 休眠状态
    • WAITING(无时限等待)
      没有CPU使用权 --- 休眠状态
    • TIMED_WAITING(有时限等待)
      没有CPU使用权 --- 休眠状态
    • TERMINATED(终止状态)
  • runnable-->blocked:
    线程等待 synchronized 的隐式锁,会促使runnable ---blocked转换
  • runnable-->waiting:

    • 获得 synchronized 隐式锁的线程,调用无参数的 Object.wait() 方法
    • 调用无参数的 Thread.join() 方法。例如有一个线程对象 thread A,当B调用 A.join() 的时候,B会等待 thread A 执行完,B状态会从 RUNNABLE 转换到 WAITING。当线程 thread A 执行完,B会从 WAITING 状态转换到 RUNNABLE
    • 调用 LockSupport.park() 方法,当前线程会阻塞,线程的状态会从 RUNNABLE 转换到 WAITING。
      调用 LockSupport.unpark(Thread thread) 可唤醒目标线程,目标线程的状态又会从 WAITING 状态转换到 RUNNABLE。
  • runnable-->TIMED_WAITING

    • 调用 带超时参数 的 Thread.sleep(long millis) 方法;
    • 获得 synchronized 隐式锁的线程,调用 带超时参数 的 Object.wait(long timeout) 方法;
    • 调用 带超时参数 的 Thread.join(long millis) 方法;
    • 调用 带超时参数 的 LockSupport.parkNanos(Object blocker, long deadline) 方法;
    • 调用 带超时参数 的 LockSupport.parkUntil(long deadline) 方法

clipboard.png

可见性、原子性

volatile它比synchronized的使用和执行成本更低,因为它不会引起线程上下文的切换和调度,sync会引起线程阻塞,会导致线程状态发生变化。

如何保证共享变量的可见性

volatile会生成lock前缀指令,会将当前处理器缓存行的数据写回到系统内存。
同时这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效,
每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了,当 处理器发现自己缓存行对应的内存地址被修改,就会将当前处理器的缓存行设置成无效状 态,当处理器对这个数据进行修改操作的时候,会重新从系统内存中把数据读到处理器缓存 里。

处理器如何保证原子性
    • 使用总线锁保证原子性
            所谓总线锁就是使用处理器提供的一个 LOCK#信号,当一个处理器在总线上输出此信号时,其他处理器的请求将被阻塞住,那么该 处理器可以独占共享内存。此时就只会有一个处理器在处理共享变量的相关操作,
            但是这种方式把CPU和内存之间的通信锁住了,这使得锁定期间,其他处 理器不能操作其他内存地址的数据。
    • 使用缓存锁保证原子性(有的处理不支持以及数据不能被缓存或者数据跨缓存行操作,无法使用此策略)
            所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存 行中,并且在Lock操作期间被锁定,那么当它执行锁操作回写到内存时,处理器不在总线上声 言LOCK#信号,而是修改内部的内存地址,并允许它的缓存一致性机制来保证操作的原子 性,因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据,当其他处 理器回写已被锁定的缓存行的数据时,会使缓存行无效
    • java如何保证原子性操作

      • 锁和CAS
        CAS是通过处理器提供的CMPXCHG指令实现的,这个指令会采用缓存锁定策略。
        而锁是除了偏向锁,JVM实现锁的方式都用了循环 CAS,即当一个线程想进入同步块的时候使用循环CAS的方式来获取锁,当它退出同步块的时 候使用循环CAS释放锁。

          但是CAS存在三个问题:
          1.ABA问题
          2.循环时间长开销大
          3.只能保证一个共享变量原子操作,而不是多个共享变量
        
        

    java内存模型

    • 重排序

      • 编译器和处理器重排序
              对于编译器,JMM的编译器重排序规则会禁止特定类型的编译器重排 序(不是所有的编译器重排序都要禁止)。
              对于处理器重排序,JMM的处理器重排序规则会要求Java编译器在生成指令序列时,插入特定类型的内存屏障(Memory Barriers,Intel称之为 Memory Fence)指令,通过内存屏障指令来禁止特定类型的处理器重排序
    • HB原则
      在JMM中,如果一个操作执行的结果需要对另一个操作可见,那么这两个操作之间必须要存在happens-before关系,而不一定是前一个操作是在后一个操作之前执行

      • 程序顺序规则:一个线程中的每个操作,happens-before于该线程中的任意后续操作
      • 监视器锁规则:对一个锁的解锁的结果,happens-before于随后对这个锁的加锁
      • volatile变量规则:对一个volatile域的写,happens-before于任意后续对这个volatile域的读。
      • 传递规则
      • 线程 start() 规则

        它是指主线程 A 启动子线程 B 后,子线程 B 能够看到主线程在启动子线程 B 前的操作。
        如果线程 A 调用线程 B 的 start() 方法(即在线程 A 中启动线程 B)
        那么该 start() 之前共享变量操作结果对线程 B 中的任意操作是可见
      • 线程 join() 规则

        如果在线程 A 中,调用线程 B 的 join() 并成功返回,
        那么线程 B 中的任意操作结果于该 join() 操作的返回后是可见。
        
        

    volatile语义,符合HB原则

       可见性:对一个volatile变量的读,总是能看到(任意线程)对这个volatile变量最后的写 入。
       原子性:对任意单个volatile变量的读/写具有原子性,但类似于volatile++这种复合操作不 具有原子性。
    • 读写语义
      当写一个volatile变量时,JMM会把该线程对应的本地内存中的共享变量值刷新到主内存。
      当读一个volatile变量时,JMM会把该线程对应的本地内存置为无效。线程接下来将从主 内存中读取共享变量
      在读线程B读一个volatile变量后,写线程A在写这个volatile变量之前所有可见的共享变量的值都将立即变得对读线程B可见。
    • 内存语义实现(插入内存屏障实现)

      • volatile写之前的操作不会被编译器重排序到volatile写之后
        即volatile写前面插入StoreStore屏障,将volatile写之前的变量刷新到内存,保证可见性
      • volatile读之后的操作不会被编译器重排序到volatile读之前
        即volatile读后面插入LoadLoad,LoadStore屏障,防止volatile后面的读写操作重排到它前面
      • 当第一个操作是volatile写,第二个操作是volatile读时,不能重排序。
        即volatile写后面插入了StoreLoad屏障,防止后面的volatile读和写排在前面

    锁的内存语义,符合HB原则

    
    当线程释放锁时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存中
    当线程获取锁时,JMM会把该线程对应的本地内存置为无效,从主内存读取。
    
    • ReentrantLock锁的内存语义
      在ReentrantLock源码可以看到,在获取锁时,是先读取state变量,这个个变量是volatile,然后在释放锁的时候,在写state变量。从HB原则,释放锁的线程在写volatile变量之前可见的共享变量,在获取锁 的线程读取同一个volatile变量后将立即变得对获取锁的线程可见;从而看出锁的获取和释放具有volatile相同的内存语义
    • CAS的内存语义
            CAS在执行的时候会插入为cmpxchg指令,判断是否是多处理器来增加LOCK前缀,lock前缀的指令会禁止它之前和之后 的读和写指令重排序。
            以及会把写缓冲区的数据刷新到内存中,这样的形式具备了volatile的相同内存语义(编译器不会对volatile读与volatile读后面的任意内存操作重排序;编译器不会对volatile写与volatile写前面的任意内存操作重排序)

    final的内存语义

    • 重排序规则

      • 在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。 即(在对象引用为任意线程可见之前,对象的final域已经被 正确初始化过了,而普通域不具有这个保障;JMM禁止编译器把final域的写重排序到构造函数之外)
      • 初次读一个包含final域的对象的引用,与随后初次读这个final域,这两个操作之间不能 重排序
        即(在读一个对象的final域之前,一定会先读包含这个final 域的对象的引用)。
      • 在构造函数内对一个final引用的对象的成员域 的写入,与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量,这两个操作之 间不能重排序。

    杂记录

    • Lock 有别于 synchronized 隐式锁的三个特点:能够响应中断、支持超时和非阻塞地获取锁
      sync阻塞了无法释放资源,无法响应中断,
    • CopyOnWriteArrayList原理

      CopyOnWriteArrayList 内部维护了一个数组,成员变量 array 就指向这个内部数组,
      所有的读操作都是基于array 进行的。
      迭代器 Iterator 遍历的就是 array 数组。
      如果在遍历 array 的同时,还有一个写操作,例如增加元素,
      CopyOnWriteArrayList 是如何处理的呢?
      CopyOnWriteArrayList 会将 array 复制一份,
      然后在新复制处理的数组上执行增加元素的操作,执行完之后再将 array 指向这个新的数组
      所以:
      '1.如果容器经常被修改或者这个数组本身就非常大的时候是不建议使用的
       2.如果是修改非常少、数组数量也不大,并且对读性能要求苛刻的场景,则使用会有好的性能提现'
      
      使用 CopyOnWriteArrayList 需要注意的“坑”主要有两个方面。
      一个是应用场景,CopyOnWriteArrayList 仅适用于写操作非常少的场景,而且能够容忍读写的短暂不一致。
      例如上面的例子中,写入的新元素并不能立刻被遍历到。
      另一个需要注意的是,CopyOnWriteArrayList 迭代器是只读的,不支持增删改。
      因为迭代器遍历的仅仅是一个快照,而对快照进行增删改是没有意义的
      
      

    以上内容来自:
    java并发编程艺术书籍以及java并发编程实战极客文章整理

    评论

    暂无评论