java基础-CAS、synchronized和AQS的理解

乐观锁与悲观锁的区别？

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中和等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于机制，其实都是提供的乐观锁。在Java中java.util..包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

两种锁的使用场景？

从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

乐观锁常见的两种实现方式

乐观锁一般会使用版本号机制或CAS算法实现。

版本号机制

一般是在数据表中加上一个数据版本号字段，表示数据被修改的次数，当数据被修改时，值会加一。当线程A要更新数据值时，在读取数据的同时也会读取值，在提交更新时，若刚才读取到的值为当前数据库中的值相等时才更新，否则重试更新操作，直到更新成功。

举一个简单的例子：

假设数据库中帐户信息表中有一个 字段，当前值为 1 ；而当前帐户余额字段（ ）为 $100 。当需要对账户信息表进行更新的时候，需要首先读取字段。

操作员 A 此时将其读出（ =1 ），并从其帐户余额中扣除 $50（ $100-$50 ）。

在操作员 A 操作的过程中，操作员B 也读入此用户信息（ =1 ），并从其帐户余额中扣除 $20 （ $100-$20 ）。

操作员 A 完成了修改工作，提交更新之前会先看数据库的版本和自己读取到的版本是否一致，一致的话，就会将数据版本号加1（ =2 ），连同帐户扣除后余额（ =$50 ），提交至数据库更新，此时由于提交数据版本大于数据库记录当前版本，数据被更新，数据库记录 更新为 2 。

操作员 B 完成了操作，提交更新之前会先看数据库的版本和自己读取到的版本是否一致，但此时比对数据库记录版本时发现，操作员 B 提交的数据版本号为 2 ，而自己读取到的版本号为1 ，不满足 “ 当前最后更新的与操作员第一次读取的版本号相等 “ 的乐观锁策略，因此，操作员 B 的提交被驳回。

这样，就避免了操作员 B 用基于 =1 的旧数据修改的结果覆盖操作员A 的操作结果的可能。

CAS算法

即 and swap（比较与交换），是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non- ）。CAS算法涉及到三个操作数

需要读写的内存值 V

进行比较的值 A

拟写入的新值 B

当且仅当 V 的值等于 A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较和替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。

乐观锁的缺点

ABA 问题是乐观锁一个常见的问题

1 ABA 问题

如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回A，那CAS操作就会误认为它从来没有被修改过。这个问题被称为CAS操作的 "ABA"问题。

JDK 1.5 以后的 ce 类就提供了此种能力，其中的 方法就是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

2 循环时间长开销大

自旋CAS（也就是不成功就一直循环执行直到成功）如果长时间不成功，会给CPU带来非常大的执行开销。 如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（ order ）而引起CPU流水线被清空（CPU flush），从而提高CPU的执行效率。

3 只能保证一个共享变量的原子操作

CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 无效。但是从 JDK 1.5开始，提供了类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行 CAS 操作.所以我们可以使用锁或者利用类把多个共享变量合并成一个共享变量来操作。

CAS与的使用情景

简单的来说CAS适用于写比较少的情况下（多读场景，冲突一般较少），适用于写比较多的情况下（多写场景，冲突一般较多）

对于资源竞争较少（线程冲突较轻）的情况，使用同步锁进行线程阻塞和唤醒切换以及用户态内核态间的切换操作额外浪费消耗cpu资源；而CAS基于硬件实现，不需要进入内核，不需要切换线程，操作自旋几率较少，因此可以获得更高的性能。

对于资源竞争严重（线程冲突严重）的情况，CAS自旋的概率会比较大，从而浪费更多的CPU资源，效率低于。

补充： Java并发编程这个领域中关键字一直都是元老级的角色，很久之前很多人都会称它为 “重量级锁” 。但是，在 1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的 偏向锁 和 轻量级锁 以及其它各种优化之后变得在某些情况下并不是那么重了。的底层实现主要依靠 Lock-Free 的队列，基本思路是 自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但获得了高吞吐量。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS。

————————————————

版权声明：本文为CSDN博主「」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：

阿里巴巴开发手册提及到 推荐使用 对象，比 性能更好（减少乐观锁的重试次数），你能帮我解读一下吗？

做累加的时候实际上就是多个线程操作同一个目标资源在高并发时，只有一个线程是执行成功的，其他的线程都会失败，不断自旋（重试），自旋会成为瓶颈；

而的思想就是把要操作的目标资源「分散」到数组Cell中；

每个线程对自己的 Cell 变量的 value 进行原子操作，大大降低了失败的次数；

这就是为什么在高并发场景下，推荐使用 的原因。

对 的理解？

是一种互斥锁，一次只能允许一个线程进入被锁住的代码块

是Java的一个关键字，它能够将代码块/方法锁起来

的原理？

当修饰方法时，编译器会生成 关键字用来标识

当修饰代码块时，会依赖和指令

无论修饰的是方法还是代码块，对应的锁都是一个实例（对象）

在内存中，对象一般由三部分组成，分别是对象头、对象实际数据和对齐填充

重点在于对象头，对象头又由几部分组成，但我们重点关注对象头Mark Word的信息就好了

Mark Word会记录对象关于锁的信息

又因为每个对象都会有一个与之对应的对象，对象中存储着当前持有锁的线程以及等待锁的线程队列

了解Mark Word和对象是理解 原理的前提

在JDK 1.6之前是重量级锁，线程进入同步代码块/方法 时

对象就会把当前进入线程的Id进行存储，设置Mark Word的对象地址，并把阻塞的线程存储到的等待线程队列中

它加锁是依赖底层操作系统的 mutex 相关指令实现，所以会有用户态和内核态之间的切换，性能损耗十分明显

而JDK1.6 以后引入偏向锁和轻量级锁在JVM层面实现加锁的逻辑，不依赖底层操作系统，就没有切换的消耗

所以，Mark Word对锁的状态记录一共有4种：无锁、偏向锁、轻量级锁和重量级锁

偏向锁指的就是JVM会认为只有某个线程才会执行同步代码（没有竞争的环境）

在Mark Word会直接记录线程ID，只要线程来执行代码了，会比对线程ID是否相等，相等则当前线程能直接获取得到锁，执行同步代码

如果不相等，则用CAS来尝试修改当前的线程ID，如果CAS修改成功，那还是能获取得到锁，执行同步代码

如果CAS失败了，说明有竞争环境，此时会对偏向锁撤销，升级为轻量级锁。

在轻量级锁状态下，当前线程会在栈帧下创建Lock ， 会把Mark Word的信息拷贝进去，且有个Owner指针指向加锁的对象

线程执行到同步代码时，则用CAS试图将Mark Word的指向到线程栈帧的Lock ，假设CAS修改成功，则获取得到轻量级锁

假设修改失败，则自旋（重试），自旋一定次数后，则升级为重量级锁

引入了偏向锁和轻量级锁，就是为了在不同的使用场景使用不同的锁，进而提高效率。锁只有升级，没有降级

1）只有一个线程进入临界区，偏向锁

2）多个线程交替进入临界区，轻量级锁

3）多线程同时进入临界区，重量级锁

版权声明：本文为CSDN博主「」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：%E5%B9%B6%E5%8F%91/03.%/

公平锁和非公平锁的区别？

公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。

优点：所有的线程都能得到资源，不会饿死在队列中。

缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。

非公平锁：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。

优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。

缺点：你们可能也发现了，这样可能导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。

AQS的理解？

是可以给我们实现锁的一个「框架」，内部实现的关键就是维护了一个先进先出的队列以及state状态变量；

先进先出队列存储的载体叫做Node节点，该节点标识着当前的状态值、是独占还是共享模式以及它的前驱和后继节点等等信息

AQS定义了模板，具体实现由各个子类完成

总体的流程可以总结为：会把需要等待的线程以Node的形式放到这个先进先出的队列上，state变量则表示为当前锁的状态。

AQS定义两种资源共享方式

（独占）：只有一个线程能执行，如。又可分为公平锁和非公平锁：

公平锁：按照线程在队列中的排队顺序，先到者先拿到锁

非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的

Share（共享）：多个线程可同时执行，如/。、、 、

原理，加锁以及解锁的过程？

加锁过程：

1):CAS尝试获取锁，获取成功则可以执行同步代码

2):CAS获取失败，则调用方法，方法实际上就是AQS的模板方法

3):首先会调用子类的方法（又回到了中）

4):方法实际上会判断当前的state是否等于0，等于0说明没有线程持有锁，则又尝试CAS直接获

5):如果CAS获取成功，则可以执行同步代码

6):如果CAS获取失败，那判断当前线程是否就持有锁，如果是持有的锁，那更新state的值，获取得到锁（这里其实就是处理可重入的逻辑）

7):CAS失败&&非重入的情况，则回到方法执行「入队列」的操作

8):将节点入队列之后，会判断「前驱节点」是不是头节点，如果是头结点又会用CAS尝试获取锁

9):如果是「前驱节点」是头节点并获取得到锁，则把当前节点设置为头结点，并且将前驱节点置空（实际上就是原有的头节点已经释放锁了）

10):没获取得到锁，则判断前驱节点的状态是否为，如果不是，则找到合法的前驱节点，并使用CAS将状态设置为

11):最后调用park将当前线程挂起

总结来说就是：当线程CAS获取锁失败，将当前线程入队列，把前驱节点状态设置为状态，并将自己挂起；

为什么要设置前驱节点为状态？

其实归终结底就是为了判断节点的状态，去做些处理。

Node 中节点的状态有4种，分别是：(1)、(-1)、(-2)、(-3)和0

在解锁的时候，会判断节点的状态是否小于0，小于等于0才说明需要被唤醒；

只有当队列没节点并且state为0时才会去获取锁，不然都会把当前线程放到队列中

解锁过程：

1):外界调用方法时，实际上会调用AQS的方法，而方法会调用子类方法（又回到了中）

2):会把state一直减（锁重入可使state>1），直至到0，当前线程说明已经把锁释放了

3):随后从队尾往前找节点状态需要 < 0，并离头节点最近的节点进行唤醒

唤醒之后，被唤醒的线程则尝试使用CAS获取锁，假设获取锁得到则把头节点给干掉，把自己设置为头节点

解锁的逻辑非常简单哈，把state置0，唤醒头结点下一个合法的节点，被唤醒的节点线程自然就会去获取锁

原子类？

是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

所以，所谓原子类说简单点就是具有原子/原子操作特征的类。

并发包 java.util. 的原子类都存放在java.util..下,如下图所示。

基本类型

使用原子的方式更新基本类型

：整形原子类

：长整型原子类

：布尔型原子类

数组类型

使用原子的方式更新数组里的某个元素

：整形数组原子类

：长整形数组原子类

：引用类型数组原子类

引用类型

：引用类型原子类

ce：原子更新引用类型里的字段原子类

nce ：原子更新带有标记位的引用类型

对象的属性修改类型

dater：原子更新整形字段的更新器

er：原子更新长整形字段的更新器

ce：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。

关键字？

它的特性：可见性和有序性(禁止重排序)

Java内存模型为了实现有序性和可见性，定义了4种内存屏障的「规范」，分别是///

就是在「前后」加上「内存屏障」，使得编译器和CPU无法进行重排序，致使有序，并且写变量对其他线程可见。

之前看过虚拟机的实现，在「汇编」层面上实际是通过Lock前缀指令来实现的，而不是各种fence指令（主要原因就是简便。因为大部分平台都支持lock指令，而fence指令是x86平台的）。

lock指令能保证：禁止CPU和编译器的重排序（保证了有序性）、保证CPU写核心的指令可以立即生效且其他核心的缓存数据失效（保证了可见性）。

Java内存模型的-规则中就有对变量规则的定义

这条规则的内容其实就是：对一个 变量的写操作相对于后续对这个 变量的读操作可见；

它通过-规则来规定：只要变量声明了 关键字，写后再读，读必须可见写的值。（可见性、有序性）

再来说内存屏障的问题，修饰之后会加入不同的内存屏障来保证可见性的问题能正确执行。这里写的屏障基于书中提供的内容，但是实际上由于CPU架构不同，重排序的策略不同，提供的内存屏障也不一样，比如x86平台上，只有一种内存屏障。

屏障，保证上面的普通写不和写发生重排序

屏障，保证写与后面可能的读写不发生重排序

屏障，禁止读与后面的普通读重排序

屏障，禁止读和后面的普通写重排序

本身随着CPU和内存的发展速度差异的问题，导致CPU的速度远快于内存，所以现在的CPU加入了高速缓存，高速缓存一般可以分为L1、L2、L3三级缓存。基于上面的例子我们知道了这导致了缓存一致性的问题，所以加入了缓存一致性协议，同时导致了内存可见性的问题，而编译器和CPU的重排序导致了原子性和有序性的问题，JMM内存模型正是对多线程操作下的一系列规范约束，因为不可能让陈雇员的代码去兼容所有的CPU，通过JMM我们才屏蔽了不同硬件和操作系统内存的访问差异，这样保证了Java程序在不同的平台下达到一致的内存访问效果，同时也是保证在高效并发的时候程序能够正确执行。

图片

原子性：Java内存模型通过read、load、、use、store、write来保证原子性操作，此外还有lock和，直接对应着关键字的和字节码指令。

可见性：可见性的问题在上面的回答已经说过，Java保证可见性可以认为通过、、final来实现。

有序性：由于处理器和编译器的重排序导致的有序性问题，Java通过、来保证。

-规则

虽然指令重排提高了并发的性能，但是Java虚拟机会对指令重排做出一些规则限制，并不能让所有的指令都随意的改变执行位置，主要有以下几点：

单线程每个操作，-于该线程中任意后续操作

写-与后续对这个变量的读

解锁-后续对这个锁的加锁

final变量的写-于final域对象的读，-后续对final变量的读

传递性规则，A先于B，B先于C，那么A一定先于C发生

关键字和 关键字的区别？

关键字是线程同步的轻量级实现，所以性能肯定比关键字要好。但是关键字只能用于变量而关键字可以修饰方法以及代码块。关键字在.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 关键字的场景还是更多一些。

多线程访问关键字不会发生阻塞，而关键字可能会发生阻塞

关键字能保证数据的可见性，但不能保证数据的原子性。关键字两者都能保证。

关键字主要用于解决变量在多个线程之间的可见性，而 关键字解决的是多个线程之间访问资源的同步性。

那锁的优化机制了解吗？

从JDK1.6版本之后，本身也在不断优化锁的机制，有些情况下他并不会是一个很重量级的锁了。优化机制包括自适应锁、自旋锁、锁消除、锁粗化、轻量级锁和偏向锁。

锁的状态从低到高依次为无锁->偏向锁->轻量级锁->重量级锁，升级的过程就是从低到高，降级在一定条件也是有可能发生的。

自旋锁：由于大部分时候，锁被占用的时间很短，共享变量的锁定时间也很短，所有没有必要挂起线程，用户态和内核态的来回上下文切换严重影响性能。自旋的概念就是让线程执行一个忙循环，可以理解为就是啥也不干，防止从用户态转入内核态，自旋锁可以通过设置-XX:+来开启，自旋的默认次数是10次，可以使用-XX:设置。

自适应锁：自适应锁就是自适应的自旋锁，自旋的时间不是固定时间，而是由前一次在同一个锁上的自旋时间和锁的持有者状态来决定。

锁消除：锁消除指的是JVM检测到一些同步的代码块，完全不存在数据竞争的场景，也就是不需要加锁，就会进行锁消除。

锁粗化：锁粗化指的是有很多操作都是对同一个对象进行加锁，就会把锁的同步范围扩展到整个操作序列之外。

偏向锁：当线程访问同步块获取锁时，会在对象头和栈帧中的锁记录里存储偏向锁的线程ID，之后这个线程再次进入同步块时都不需要CAS来加锁和解锁了，偏向锁会永远偏向第一个获得锁的线程，如果后续没有其他线程获得过这个锁，持有锁的线程就永远不需要进行同步，反之，当有其他线程竞争偏向锁时，持有偏向锁的线程就会释放偏向锁。可以用过设置-XX:+开启偏向锁。

轻量级锁：JVM的对象的对象头中包含有一些锁的标志位，代码进入同步块的时候，JVM将会使用CAS方式来尝试获取锁，如果更新成功则会把对象头中的状态位标记为轻量级锁，如果更新失败，当前线程就尝试自旋来获得锁。

整个锁升级的过程非常复杂，我尽力去除一些无用的环节，简单来描述整个升级的机制。

简单点说，偏向锁就是通过对象头的偏向线程ID来对比，甚至都不需要CAS了，而轻量级锁主要就是通过CAS修改对象头锁记录和自旋来实现，重量级锁则是除了拥有锁的线程其他全部阻塞。