多线程安全小结-可见性（内存屏障，共享变量副本）、原子性、有序性（编译器优化、cpu流水线乱序）

我不是女神ヾ 2024-02-19 12:23 5阅读 0赞

摘要：

java多线程安全要满足：***原子性***、***可见性***、***有序性***。

手段有：**不共享**；**不可变状态对象**；**互斥锁**；**同步工具类**；**线程安全工具类**

本文为本人阅读[《Java并发编程实战》][Java]的理解和总结，[java多线程安全性基础介绍.pptx][java_.pptx]

多线程知识

*  前提
    
     *  什么是线程
        
         *  线程
            
             *  任务（调度运行,run()代码执行）和资源（cpu时间，内存）的抽象
             *  线程是CPU调度的基本单位
             *  实现
                
                 *  实现方式
                    
                     *  使用内核线程实现
                        
                         *  操作系统内核
                         *  1:1
                     *  使用用户线程实现
                        
                         *  不需要切换内核态
                         *  进程与用户线程之间1：N
                     *  使用用户线程加轻量级进程混合实现
                        
                         *  N:M
                 *  java线程
                    
                     *  自JDK1.2开始基于操作系统原生线程模型来实现。
                     *  Sun JDK,它的Windows版本和Linux版本都使用一对一的线程模型实现，一条Java线程就映射到一条轻量级进程之中。
                     *  api
                        
                         *  继承Thread类
                         *  实现Runnable
             *  java线程调度
                
                 *  系统为线程分配处理器使用权的过程
                    
                     *  协同式
                        
                         *  线程执行时间由线程本身来控制，线程完成工作后主动通知系统切换线程
                         *  切换操作对线程自己是可知的，没啥线程同步问题
                         *  坏处是线程执行时间不可控制
                     *  抢占
                        
                         *  每个线程将由系统来分配执行时间，线程的切换不由线程本身来决定
                 *  java使用抢占式
                    
                     *  其优先级依赖于操作系统，不可靠
                 *  线程调度相关api
                    
                     *  sleep和wait的区别
                        
                         *  sleep是Thread类的静态方法，不释放对象锁，程序睡眠指定时间后继续竞争cpu后运行
                         *  wait是Object的方法，释放对象锁，被叫醒之后，还要获取对象锁和cpu才能运行
                     *  sleep
                        
                         *  sleep(0)的作用，睡眠0秒（并触发系统重新计算线程的优先级）
                     *  join
                        
                         *  加入
                         *  阻塞调用线程，直到某个线程终止或经过了指定时间为止
                         *  调用的线程加入执行，并阻塞所在线程
                     *  yield
                        
                         *  让出
             *  独立栈，共享堆内存
                
                 *  线程越多占用栈空间越多
                 *  线程数目有上限
                    
                     *  windows
                        
                         *  https://helpcdn.aliyun.com/knowledge\_detail/41076.html
                         *  可提交虚拟内存限制
                     *  linux
                        
                         *  系统可生成最大线程数
                            
                             *  cat /proc/sys/kernel/threads-max
                         *  进程最大线程数
                            
                             *  ps -eLf | grep 项目名 | wc -l 查看单个项目线程数
                             *  cat /proc/sys/vm/max\_map\_count
                             *  jvm的启动参数-Dconfig.server.maxThreads
                         *  用户最大进程数
                            
                             *  ulimit -a
                                
                                 *  max user processes
                         *  整个系统已用的线程或进程数
                            
                             *  cat /proc/sys/kernel/pid\_max
                             *  修改
                                
                                 *  echo "65535" > /proc/sys/kernel/pid\_max
                         *  解决内存不足导致无法创建线程
                            
                             *  \-Xss参数调小
                             *  \-Xmx调大
             *  线程的状态
                
                 *  生命周期
                    
                     *  是否启动
                        
                         *  start
                     *  运行
                        
                         *  资源
                            
                             *  cpu时间片
                                
                                 *  有
                                    
                                     *  cpu+锁
                                        
                                         *  运行
                                 *  无
                                    
                                     *  就绪
                                     *  等待
                             *  锁
                                
                                 *  没获取到
                                    
                                     *  阻塞
                         *  调度资源协调
                            
                             *  睡眠
                                
                                 *  放弃cpu，保留锁
                             *  等待
                                
                                 *  放弃cpu，放弃锁
                             *  唤醒
                                
                                 *  开始抢cpu时间片
                     *  终止
                 *  \+ - 状态分类
                    
                     *  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
                        
                        2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
                        
                        线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
                        
                        3.阻塞(BLOCKED)：表示线程阻塞于锁。
                        
                        4.等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
                        
                        5.超时等待(TIMED\_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
                        
                        6. 终止(TERMINATED)：表示该线程已经执行完毕。
     *  线程的内存模型
        
         *  运行时数据区
            
             *  线程私有
                
                 *  栈
                    
                     *  PC 寄存器
                        
                         *  每一条 Java 虚拟机线程都有自己的 PC（Program Counter）寄存器。
                         *  值
                            
                             *  该线程的当前方法
                             *  undefined
                     *  Java 虚拟机栈
                        
                         *  每一条 Java 虚拟机线程都有自己私有的 Java 虚拟机栈（Java Virtual Machine Stack）
                         *  栈帧
                            
                             *  局部变量
                     *  本地方法栈
             *  线程共享
                
                 *  堆
                    
                     *  方法区
                        
                         *  运行时常量 池（Runtime Constant Pool）、字段和方法数据、构造函数和普通方法的字节码内容
                     *  运行时常量池
                        
                         *  每一个类或接口的常量池Constant\_Pool的运行时表示形式
     *  线程的调度cpu时间片分配
 *  线程安全
    
     *  正确性
     *  什么是线程安全性
        
         *  原子性
            
             *  竞态条件
                
                 *  i++
                    
                     *  读i
                     *  \++
                     *  值写回i
         *  可见性
            
             *  JMM
             *  由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。
             *  各线程之间变量不可见，线程通信通过共享主内存实现。
             *  volatile
                
                 *  仅保证可见性
                 *  作用
                    
                     *  不会被缓存在寄存器或其他对cpu不可见的地方
                        
                         *  强制其他线程读主内存
                     *  编译器和运行时不会讲该变量的操作与其他内存操作一起重排序
             *  锁不仅保证原子性还保证可见性
         *  有序性
     *  多个线程操作共享对象导致的状态不一致问题
     *  原因
        
         *  共享资源的竞态条件问题
         *  问题
            
             *  竞态条件
             *  指令重排序
             *  工作内存中主内存同步延迟
 *  解决
    
     *  要有安全策略文档或注释
     *  不共享
        
         *  线程封闭
            
             *  仅在单线程内访问数据
         *  栈封闭
            
             *  局部变量
         *  threadLocal
            
             *  为每个线程保存一个副本
             *  类似于一个以线程id为key的map
     *  不可变对象状态
        
         *  final
     *  关键共享资源上互斥，变并发为串行即同步
        
         *  锁
            
             *  分类
                
                 *  显示锁
                    
                     *  Lock
                        
                         *  Lock是个接口
                         *  实现类
                            
                             *  ReentrantLock
                                
                                 *  可重入锁
                             *  ReentrantReadWriteLock.ReadLock
                             *  ReentrantReadWriteLock.WriteLock
                 *  隐式锁（内置锁）
                    
                     *  Synchronized
             *  问题
                
                 *  死锁
                 *  性能
                 *  线程活跃与线程饥饿
         *  同步工具类
            
             *  原子操作类
                
                 *  AtomicInteger等
                 *  相当于加上synchronized
                 *  也有些利用硬件底层能力CAS
 *  线程安全工具类
    
     *  自动加synchronized或使用底层能力支持。
     *  Atomic类， AtomicInteger无锁定的线程安全操作类。
     *  ConcurrentHashMap 分段加锁。
     *  CopyOnWriteArrayList写时复制，每次写数据之前就重新创建对象。
     *  CountDownLatch闭锁，等待多个线程完成后再继续执行。
     *  CyclicBarrier回环栅栏,让一组线程等待至某个状态之后再全部同时执行。
     *  Semphore基于计数的信号量。 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可
     *  BlockingQueue阻塞队列没数据的时候就阻塞，多线程间的生产者消费者问题。
 *  零散知识点
    
     *  Long与double操作并不是原子的
        
         *  64位是分为两个32位分两次赋值的，如果多线程赋值无法保证顺序正常
         *  说明
            
             *  1.基本类型，引用类型的指定，引用是原子的操作；
             *  2.但是long与double的指定，引用是分割的；
             *  3.要在线程间共享long与double字段是，必须在synchronized中操作，或是声明为volatile。
 *  线程停止
    
     *  run执行完成
     *  根据结束标识return
     *  调用interrupted()
        
         *  可以使sleep的线程抛异常退出
 *  #### [java多线程安全性介绍ppt下载][java_ppt] ####

[Java]: https://download.csdn.net/download/shy_snow/10249967
[java_.pptx]: https://download.csdn.net/download/shy_snow/11431122
[java_ppt]: https://download.csdn.net/download/shy_snow/10702580