way-to-architect
  • 前言
  • Java
    • Java关键字
      • Java中四种修饰符的限制范围
      • static和final
    • 容器
      • 容器概述
        • 容器:综述
        • Iterator原理及实现
        • fast-fail机制
        • 比较器Comparator
        • Collections工具类
      • List
        • List综述
        • ArrayList原理分析
        • ArrayList在循环过程中删除元素的问题
        • 常用的小技巧
        • CopyOnWrite
      • Set
        • Set综述
        • HashSet
        • LinkedHashSet
        • TreeSet
      • Queue
        • Queue综述
        • ArrayBlockingQueue实现原理
        • LinkedBlockingQueue实现原理
        • 高性能无锁队列Disruptor
      • Map
        • Map综述
        • HashMap
          • HashMap实现原理
          • HashMap中的位运算
          • HashMap其他问题
        • LinkedHashMap
        • TreeMap
        • ConcurrentHashMap
          • ConcurrentHashMap实现原理JDK1.7
          • ConcurrentHashMap实现原理JDK1.8
        • ConcurrentSkipListMap
        • Map中key和value的null的问题
    • 线程
      • 线程
        • 创建线程
        • 线程状态及切换
        • 线程中断的理解
        • 几种方法的解释
        • 用户线程与守护线程
        • 线程组ThreadGroup
      • 线程池
        • 线程池工作原理及创建
        • Executor
        • 如何确保同一属性的任务被同一线程执行
      • ThreadLocal
        • ThreadLocal原理
        • ThreadLocal之父子线程传值
        • InheritableThreadLocal
      • 同步与锁
        • 线程安全与锁优化
        • synchronize关键字
        • Lock
          • 队列同步器
            • 同步状态的获取与释放
            • 使用方式
            • 示例:Mutex
            • 示例:TwinsLock
          • 重入锁和读写锁
          • LockSupport
          • Condition
          • 并发工具类
        • CAS
          • CAS的理解
          • Java中原子操作类
        • 3个经典同步问题
      • fork/join的理解
    • I/O
      • I/O概述
        • 磁盘I/O与网络I/O
        • 主要接口
        • 输入流和输出流的使用示例
        • InputStream的重复读
        • BufferdxxxxStream
        • Serailizable
        • File常用方法
        • Files和Path
        • RandomAccessFile
        • 通过零拷贝实现有效数据传输
        • 正确地处理文件
      • NIO基础
      • NIO2
      • Netty
        • Java I/O的演进之路
        • 为什么是Netty
        • 更多
      • I/O调优
    • 异常
      • 异常体系及为什么要有这种异常设计
      • 多catch的执行情况
      • try catch finally 与reture
      • 异常处理的误区
      • Preconditions:方法入参校验工具
    • 枚举
      • 常见用法
      • 枚举类在序列化中的问题
    • 注解
      • 概述
      • Spring中的组合注解的条件注解
      • 常用注解
        • JSR-330标准注解
    • 反射
      • 概述
      • 内部类的反射
      • 反射中需要注意的地方
    • 流程控制
      • switch case without break
      • Java: for(;;) vs. while(true)
    • JVM
      • JVM内存结构
      • Java内存模型
      • 垃圾收集器和内存分配策略
      • 四种引用类型区别及何时回收
      • 类文件结构
      • 类初始化顺序
      • 类加载机制
      • 虚拟机执行引擎
      • 逃逸分析
      • JVM常用配置
      • GC日志分析
      • Java8 JVM 参数解读
      • 垃圾收集器和内存分配策略
    • 面向对象
      • Object类中的方法
      • Class类中的方法
      • 值传递还是引用传递?
      • 接口和抽象类的区别
      • 深拷贝和浅拷贝
      • Integer.parseInt()与Interger.valueof()
      • hashCode()与equal()
      • String
        • String池化及intern()方法的作用
        • 关于字符串
    • 序列化
      • Java序列化的方式有哪些?
    • 新特性
      • 流 Stream
        • Stream是什么
        • Stream API详解
        • Stream进阶
        • 流编程
        • 其他事项
      • lambda表达式
      • 默认方法(Default Methods)
      • @FunctionalInterface注解
    • SPI
      • 理解SPI
    • 字节码
      • javaagent
      • 字节码操纵
      • 如何查看类编译后的字节码指令
      • 字节码指令有哪些
  • Python
    • 异常处理
  • Go
  • 数据结构与算法
    • 数据结构
      • 概述
        • 线性表
        • 栈
        • 队列
        • 串
        • 树
        • 图
      • Java的一些实现
      • 红黑树
      • 双缓冲队列
      • 跳表SkipList
    • 算法
      • 概述
      • 常见算法
        • 基本排序
        • 高级排序
        • 动态规划
  • 框架或工具
    • Spring
      • Spring基础
        • Spring整体架构
        • 什么是IoC
        • Ioc容器的基本实现
        • Spring的MainClass
          • Spring的BeanFactory
          • Spring的Register
          • Spring的Resource和ResourceLoader
          • Spring的PropertySource
          • Spring的PropertyResolver
          • Spring的PropertyEditor
          • Spring的Convert
          • Spring的BeanDefinition
          • Spring的BeanDefinitionReader
          • Spring的BeanDefiniton其他Reader
          • Spring的BeanDefinition其他Reader2
          • Spring的Aware
          • Spring的BeanFctoryPostProcessor
          • Spring的BeanPostProcessor
          • Spring的Listener
        • Xml格式的应用启动
          • Xml格式的应用启动2
          • Xml格式的应用启动3
          • Xml格式的应用启动4
          • Xml格式的应用启动5
          • Xml格式的应用启动6
          • Xml格式的应用启动7
        • Spring中的设计模式
        • 什么是AOP
        • Spring中AOP的实现
      • Spring应用
        • Spring的事务控制
        • @Transactional注解在什么情况下会失效
        • 如何在数据库事务提交成功后进行异步操作
        • Spring中定时任务的原理
    • SpringMVC
      • Controller是如何将参数和前端传来的数据一一对应的
      • 请求处理流程
    • Zookeeper
      • Zookeeper是什么
      • Zookeeper能干啥
    • Shiro
    • druid
    • Netty
    • Consul
      • Consul是什么
    • etcd
    • confd
    • Akka
      • Actor模型是什么
  • 数据库
    • 基本概念
    • MySQL
      • 基本配置
      • MySQL数据类型
      • MySQL存储引擎
      • MySQL事务
        • MySQL事务概念
      • MySQL索引
        • MySQL中的索引类型
        • B-Tree/B+Tree概述
        • 为什么使用B+Tree
        • MySQL中的B+Tree索引
        • MySQL高性能索引策略
      • MySQL查询
        • MySQL查询过程
        • MySQL查询性能优化
        • 使用EXPLAIN
      • MySQL锁
        • MySQL中锁概述
        • InnoDB的并发控制
        • MySQL乐观锁
      • MySQL分库分表
        • 分库/分表
        • 跨库JOIN
        • 跨库分页
        • 分库分表后的平滑扩容
        • 分区表
        • 分布式ID生成方法
      • MySQL实战
        • 在线表结构变更
        • MySQL优化规则
        • MySQL问题排查
        • 常见查询场景
    • Redis
    • Hbase
    • OpenTSDB
    • rrd
    • MongoDB
    • 连接池
  • 系统设计
    • 一致性Hash算法
    • 限流
      • 限流是什么
      • 限流算法
      • 应用内限流
      • 分布式限流
      • 接入层限流
        • ngx_http_limit_conn_module
        • ngx_http_limit_req_module
        • lua_resty_limit-tarffic
      • 节流
    • 降级
      • 降级详解
      • 人工降级开关的实现
      • 自动降级的实现:Hystrix
    • 负载均衡
      • 概述
      • 互联网架构下的负载均衡
      • Nginx负载均衡(七层)
      • Nginx负载均衡(四层)
      • Nginx动态配置
    • 超时与重试机制
      • 什么地方要超时与重试
      • 代理层超时与重试
      • Web容器超时
      • 中间件客户端超时与重试
      • 数据库超时
      • NoSQL客户端超时设置
      • 业务超时
      • 前端请求超时
    • 网关
    • CAP
      • 什么是CAP
      • CAP理解
    • 生产者-消费者模型
      • 使用notify/wait方式
      • 使用await/signal实现
      • 使用阻塞队列实现
      • 使用信号量实现
      • 使用管道流实现
      • 无锁队列Disruptor
      • 双缓冲队列
    • 缓存
      • 缓存概述
      • 数据库缓存
      • 应用缓存
      • 前端缓存
      • 本地缓存
    • 秒杀
    • LRU
  • 版本控制
    • Git
      • Git常用命令
      • 场景命令
    • Svn
  • 计算机操作系统
    • Linux
      • Linux中重要概念
      • 常用命令
      • 查看日志
      • 权限管理
      • 登录或传输
      • 防火墙
      • 配置ssh免密
      • 进程
      • 防火墙
    • Mac
    • 计算机基础
      • 进制
      • Java中的位运算
      • 计算机存储系统结构
  • 网络
    • TCP三次握手和四次挥手
    • 网络术语
      • 网关、路由器、交换机、IP等
      • VLAN
      • LAN
  • 设计模式
    • 设计模式概述
    • 创建型
      • 单例模式
      • 工厂模式
      • 建造者模式
      • 原型模式
      • 享元模式
    • 行为型
      • 观察者模式
      • 策略模式
      • 模板模式
      • 责任链模式
      • 命令模式
      • 外观模式
      • 迭代器模式
      • 中介者模式
        • 中介模式续
      • 状态模式
        • 状态模式实例
        • 状态模式思考
      • 访问者模式
        • 访问者实例1
        • 访问者模式续
    • 结构型
      • 组合模式
        • 组合模式续
      • 装饰模式
        • 装饰模式续
      • 代理模式
      • 备忘录模式
      • 桥接模式
        • 桥接模式实例一
  • 构建工具
    • Maven
      • 常用命令
      • Maven生命周期
      • Maven中的变量和属性
      • 不同环境的如何配置不同的变量
      • 常用插件及配置
      • 其他问题
      • dependencies与dependencyManagement的区别
    • Gradle
  • 大数据
    • Hadoop
    • Storm
    • Spark
  • 服务器
    • Tomcat
      • server.xml配置详解
      • 线程池和连接数配置
      • Maven远程部署
      • 一些小技巧
      • Tomcat类加载机制分析
      • Tomcat的日志
      • Tomcat架构
        • 概述
        • Server 的启动流程
        • 请求处理流程
    • Nginx
      • 常用命令
      • 基本配置
      • Lua
    • Tengine
  • 中间件
    • 任务调度
      • 为什么需要任务调度
    • 消息队列
      • 为什么需要消息队列
      • 消息队列关键点
      • 消息中间件需要解决的问题
      • 不同消息队列产品对比
      • RocketMQ
        • 快速入门
        • 整体架构
        • 部署方式
          • Broker部署方案
        • 客户端使用
          • 客户端使用指南
          • 快速开始
          • 简单示例
          • 有序消息示例
          • 广播消息示例
          • 定时消息示例
          • 批量消息示例
          • 过滤消息示例
          • 日志输出配置示例
        • 关键点实现
          • 顺序消息的实现
        • 最佳实践
          • Broker的最佳实践
          • 生产者最佳实践
            • 生产者最佳实践续
          • 消费者最佳实践
            • 消费者最佳实践续
          • 名称服务最佳实践
          • JVM/kernel配置的最佳实践
          • 新特性 Filter Server
          • 其他事项
      • RabbitMQ
      • Kafka
    • 分布式事务
      • 什么是分布式事务
      • 解决方案
    • 服务治理
      • RPC概念
      • RPC最简实现
      • 为什么需要服务治理
      • Dubbo
        • Dubbo整体架构
      • Java RMI
    • 分布式锁
      • 如何设计分布式锁
        • 基于zookeeper
        • 基于Redis
    • 注册中心
      • 注册中心的职责
      • 不同注册中心的比较
    • 配置中心
      • 概述
      • 配置中心的实现与选型
  • Web开发
    • Http请求类型及区别
    • 常见的content-type
    • 如何处理跨域
    • Restful最佳实践
    • HTTP状态码
    • Http下载原理
  • 测试
    • 压测:apache bench
    • 压测:Jmeter
Powered by GitBook
On this page
  • Java语言中的线程安全
  • 线程安全的实现方法
  • 互斥同步(阻塞同步)
  • 非阻塞同步
  • 无同步方案
  • 锁优化
  • 自旋锁与自适应自旋
  • 锁消除
  • 锁粗化
  • 轻量级锁
  • 偏向锁
  1. Java
  2. 线程
  3. 同步与锁

线程安全与锁优化

《Java Concurrency In Practice》中Brian Goetz:当多个线程访问同一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他的协调操作,调用这个对象的行为都可以获取正确的结果,那这个对象就是线程安全的。

但这个定义很严格,一般情况下很难达到这种要求。

Java语言中的线程安全

讨论线程安全,就限定于多个线程之间存在共享数据的访问这个前提,因为如果一段代码根本不会与其他线程进行共享数据,那么从线程安全的角度看,程序是串行执行还是多线程执行对它来说是完全没有区别的。

按照线程安全的安全程度由强至弱的顺序,可以将Java语言中的各种操作共享的数据分为以下5类。

  • 不可变 不可变(Immutable)对象一定是线程安全的,无需采取任何线程安全保障措施。

    • 对一个基本数据类型,使用final关键字修饰,它就是不可变的。

    • 对一个对象,则需要保证对象的行为不会对其状态产生任何影响:保证对象行为不影响自己状态的最简单的途径就是把对象中带有状态的变量都声明为final。 在Java API中符合不可变要求的类型有:String、枚举类型、java.lang.Number的部分子类(Long和Double等数值包装类,BigInteger和BigDecimal等大数据类型,但AtomicInteger和AtomicLong并非不可变)。

  • 绝对线程安全 绝对安全的线程的类,完全符合Brian Goetz的定义,但在Java API中标注自己是线程安全的类,大多数都不是绝对的线程安全,如Vector。

  • 相对线程安全 是通常意义上的线程安全,它需要保证对这个对象单独的操作是线程安全的,在调用的时候不需要做额外的保证措施。但是对于一些特定顺序的连续调用,就可能需要在调用端使用额外的同步手段来保证调用的正确性。 在Java语言中,大部分线程安全类都属于这种类型,如Vector、HashTable、Collections的synchronizedCollection()方法包装的集合等。

  • 线程兼容 线程兼容是指对象本身不是线程安全的,但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中是可以安全使用的。Java API中的大部分的类都是属于线程兼容的,如ArrayList和HashMap等。

  • 线程对立 线程对立是指无论调用端是否采取了同步措施,都无法在多线程环境中使用的代码。线程对立这种排斥多线程的代码是很少出现的,通常都是有害的,应当避免。如Thread类的suspend()和resume()方法。如果两个线程同时持有一个线程对象,两个线程并发对该线程对象执行suspend()和resume()方法,无论是否采用了同步,都存在死锁风险。

线程安全的实现方法

如何实现线程安全与代码编写有很大关系,理解虚拟机提供的同步和锁机制对编写线程安全的代码很重要。

同步概念 同步是指在多个线程并发访问共享数据时,保证共享数据在同一个时刻只被一个(或者是一些,使用信号量的时候)线程使用。

互斥同步(阻塞同步)

互斥是实现同步的一种手段,而互斥的实现方式主要有临界区、互斥量、信号量。

  • synchronize关键字

  • 重入锁ReentrantLock

synchronized和ReentrantLock性能:在JDK1.6及以上,synchronized和ReentrantLock性能基本持平,虚拟机在未来的性能改进中会更偏向于原生的synchronized,在synchronized可以实现需求的情况下,优先考虑使用synchronized。

互斥同步最主要的问题是进行线程阻塞和唤醒时带来的性能问题,这种同步也称为阻塞同步Blocking Synchronization。从处理问题的方式来说,互斥同步属于一种悲观的并发策略:总是认为只要不去做正确的同步措施(加锁),那就肯定会出问题。无论共享数据是否真的会出现竞争,它都进行加锁、用户态核心态转换、维护锁计数器、检查是否有被阻塞的线程需要唤醒等操作。

非阻塞同步

非阻塞同步是一种基于冲突检测的乐观并发策略的同步操作:先进行操作,如果没有其他线程争用共享数据,那操作就成功;如果共享数据有争用,产生了冲突,就在采取其他的补偿措施(比如不断的重试,直到成功)。这种乐观并发策略的很多实现都不需要把线程挂起,因此称为非阻塞同步。

乐观并发策略需要硬件指令集的发展,因为上述过程中的操作和冲突检测这两个步骤需要具备原子性,而这种原子性保证如果使用互斥手段实现就失去意义,所以只能靠硬件通过一条处理器指令来完成这种从语义上看起来需要多次操作的行为。这里的非阻塞同步进行的操作主要涉及CAS(Compare And Swap)这条指令。使用该指令完成的操作具备原子性,称为CAS操作。

无同步方案

如果一个方法本来就不涉及共享数据,那它就无须任何同步措施。 (个人理解就是变量线程私有化)

  • 可重入代码 可重入代码的特征:不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数传入、不调用非可重入的方法等。 判断代码是否具有可重入性:对于一个方法,如果输入了相同的数据,就都能返回相同的结果,那它就满足可重入性的要求,也是线程安全的。

  • 线程本地存储 通过ThreadLocal类来实现线程本地存储的功能。

锁优化

锁优化技术(HotSpot虚拟机而言)包括适应性自旋、锁消除、锁粗化、轻量级锁和偏向锁等。这些技术都是为了在线程之间更高效地共享数据以及解决竞争问题,从而提高程序效率。

自旋锁与自适应自旋

在互斥同步的时候,为了消除线程切换带来的性能消耗,让等待锁的线程执行一个忙循环(自旋),而不放弃处理器的执行时间,看看持有锁的线程是否很快就会释放锁。这就是自旋锁。

自旋等待虽然避免了线程切换的开销,但如果锁被占用很长时间,自旋的线程只会白白浪费处理器资源,所以自旋等待的时间要有一定限度。如果自旋超过了限定的次数仍然没有成功获得锁,就使用传统的方式挂起线程。自旋默认的次数是10,可以通过参数-XX:PreBlockSpin更改。

JDK1.6中引入了自适应的自旋锁:自旋时间不固定,而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。如果在同一个锁对象上,自旋等待刚刚成功获得过锁,并且持有锁的线程正在运行,那么虚拟机就会认为这次自旋也很有可能再次成功,并将自旋等待时间延长。如果对于某个锁,自旋很少成功,那么在之后获取该锁时可能会放弃不自旋直接挂起线程。

锁消除

锁消除是指虚拟机即时编译器在运行时,对一些代码上要求同步,但是被检测到不可能存在共享数据竞争的锁进行消除。锁消除的主要判断依据来源于逃逸分析的数据支持,如果判断在一段代码中,堆上的所有数据都不会逃逸出去从而被其他线程访问到,那就可以把它们当做栈上数据对待,认为它们是线程私有的,同步加锁就无需进行。 这种情况主要是一些Java API中类自己的同步的消除,因为一般在编写代码时都会清除哪些数据存在竞争。

锁粗化

原则上,在编写代码时,总是应该将同步块的作用范围限制得尽量小,以便使需要同步的操作数量尽可能变小,如果存在锁竞争,那等待锁的线程也能尽快拿到锁。 但是,如果一系列的连续动作都对同一对象反复加锁和解锁,甚至加锁操作时出现在循环体中的,那即使没有线程竞争,频繁地进行互斥同步操作也会导致不必要的性能损耗,比如连续的append()方法。

轻量级锁

轻量级锁的加锁过程:在代码进入同步块的时候,如果此对象没有被锁定(标志位为01),虚拟机首先在当前线程的栈帧中创建一个空间(称为锁记录Lock Record),用于存储锁对象目前的Mark World的拷贝。然后,虚拟机将使用CAS操作尝试将对象的Mark World更新为指向锁空间的指针,如果更新成功,那么这个线程就拥有了该对象的锁,并且对象Mark World的锁标志位将变为00,即表示此对象处于轻量级锁定状态。如果更新失败,虚拟机首先会检查对象的Mark World是否指向当前线程的栈帧,如果是,说明当前线程已经拥有了该对象的锁,就可以直接进入同步块,如果不是,说明这个锁对象已经被其他线程占用了。如果有两个以上线程争用同一个锁,轻量级锁就不再有效,就要膨胀为重量级锁,锁标志位变为10。

轻量级锁的解锁过程:如果对象的Mark World仍然指向着线程的锁记录,就用CAS操作把对象当前的Mark World和线程中复制的Mark World的拷贝替换回来,如果替换成功,整个同步过程就结束。如果失败,说明其他线程尝试过获取锁,就需要在释放锁的时候,唤醒被挂起的线程。

轻量级锁提升程序同步性能的依据是:对于绝大部分的锁,在整个同步周期内都不存在竞争。但如果存在锁竞争,依然会使用重量级锁,还额外发生了CAS操作,因此在有竞争的情况下,轻量级锁比传统的重量级锁更慢。

偏向锁

偏向锁是JDL1.6引入的锁优化技术,它比轻量级锁更进一步:在无竞争的情况下,把整个同步都消除掉,连CAS操作也不做。 偏向锁中的“偏向”是指锁偏向于第一个获取它的线程,如果在接下来的执行过程中,该锁没有被其他的线程获取,则持有偏向锁的线程永远不需要同步。 偏向锁的原理:当锁对象第一次被线程获取的时候,虚拟机将Mark World的标志位设为偏向模式(01),同时使用CAS操作将获取到该锁的线程ID记录在Mark World之中。如果CAS操作成功,持有偏向锁的线程以后每次进入这个锁的同步块时,虚拟机都不再进行任何同步操作。当有另外的线程尝试获取该锁时,偏向模式就结束了。此时,根据锁对象目前是否处于被锁定的状态,撤销偏向后恢复到未锁定或者轻量级锁的状态。后续的操作就如同轻量级锁那样执行。 偏向锁可以提高带有同步但无竞争的程序性能,是一个带有效益权衡(Trade Off)性质的优化,它并不一定总是对程序运行有利。如果程序中总是被多个不同的线程访问,那偏向模式就是多余的。

Previous同步与锁Nextsynchronize关键字

Last updated 6 years ago

轻量级锁是JDK1.6中加入的新型锁机制。轻量级锁并不是用来代替重量级锁的,它的本意是在没有多线程竞争的前提下,减少传统的重量级锁使用操作系统互斥量产生的性能消耗。 理解轻量级锁必须从HotSpot虚拟机中的对象的对象头的信息开始。关于对象头尤其是对象头中Mark World的内容可以参考。

对象的创建、内存布局、访问定位