java并发编程——锁优化

灰太狼 2022-05-15 02:21 290阅读 0赞

**本博文目录为：**

**一.  线程安全的实现方法**

**二.  锁的优化**

**三.  乐观锁与悲观锁**

# 一.   线程安全的实现方法 #

### 1. 互斥同步 ###

互斥同步（Mutual Exclusion & Synchronization）是常见的一种并发正确性保障手段。**同步**是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个（或者是一些，使用信号量的时候）线程使用。而**互斥**是实现同步的一种手段，临界区（Critical Section）、互斥量（Mutex）和信号量（Semaphore）都是主要的互斥实现方式。因此，在这 4 个字里面，**互斥是因，同步是果；互斥是方法，同步是目的。**

在 Java 中，最基本的互斥同步手段就是 synchronized 关键字，synchronized 关键字经过编译之后，会在同步块的前后分别形成 monitorenter 和 monitorexit 这两个字节码指令，这两个字节码都需要一个 reference 类型的参数来指明要锁定和解锁的对象。如果 Java 程序中的 synchronized 明确指定了对象参数，那就是这个对象的 reference；如果没有明确指定，那就根据 synchronized 修饰的是实例方法还是类方法，去取对应的对象实例或 Class 对象来作为锁对象。

根据虚拟机规范的要求，在执行 monitorenter 指令时，首先要尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象的锁，把锁的计数器加 1，相应的，在执行 monitorexit 指令时将锁计数器减 1，当计数器为 0 时，锁就被释放。如果获取对象锁失败，那当前线程就要阻塞等待，知道对象锁被另外一个线程释放为止。

在虚拟机规范对 monitorenter 和 monitorexit 的行为描述中，有两点是需要特别注意的。首先，**synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题**。其次，同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。在前面讲过，**Java 的线程是映射到操作系统的原生线程之上的，如果要阻塞或唤醒一个线程，都需要操作系统来帮忙完成，这就需要从用户态转换到核心态中，因此状态转换需要耗费很多的处理器时间**。对于代码简单的同步块（如被 synchronized 修饰的 getter() 或 setter() 方法），状态转换消耗的时间有可能比用户代码执行的时间还要长。所以 synchronized 是 Java 语言中一个重要级（Heavyweight）的操作，有经验的程序员都会在确实必要的情况下才使用这种操作。而虚拟机本身也会进行一些优化，譬如在通知操作系统阻塞线程之前加入一段自旋等待过程，避免频繁地切入到核心态之中。

除了 synchronized 之外，我们还可以使用 java.util.concurrent（下文成 J.U.C）包中的重入锁（ReentrantLock）来实现同步，在基本用法上，ReentrantLock 与 synchronized 很相似，他们都具备一样的线程重入特性，只是代码写法上有点区别，一个表现为 **API 层面的互斥锁**（lock() 和 unlock() 方法配合 try/finally 语句块来完成），另一个表现为**原生语法层面的互斥锁**。不过，相比 synchronized，ReentrantLock 增加了一些高级功能，主要有以下 3 项：等待可中断、可实现公平锁，以及锁可以绑定多个条件。

*  等待可中断是指当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
 *  公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
 *  锁绑定多个条件是指一个 ReentrantLock 对象可以同时绑定多个 Condition 对象，而在 synchronized 中，锁对象的 wait() 和 notify() 或 notifyAll() 方法可以实现一个隐含的条件，如果要和多于一个的条件关联的时候，就不得不额外添加一个锁，而 ReentrantLock 则无须这样做，只需要多次调用 newCondition() 方法即可。

如果需要使用上述功能，选用 ReentrantLock 是一个很好的选择，那如果是基于性能考虑呢？JDK 1.6 中加入了很多针对锁的优化措施，JDK 1.6 发布之后，人们就发现 synchronized 与 ReentrantLock 的性能基本上是完全持平了。因此，如果读者的程序是使用 JDK 1.6 或以上部署的话，性能因素就不再是选择 ReentrantLock 的理由了，虚拟机在未来的性能改进中肯定也会更加偏向于原生的 synchronized，所以还是提倡在 synchronized 能实现需求的情况下，优先考虑使用 synchronized 来进行同步。

### **2. 非阻塞同步** ###

互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步（Blocking Synchronization）。**从处理问题的方式上来说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁**（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户 态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择：**基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断地重试，知道成功为止）**，这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）。

为什么笔者说使用乐观并发策略需要 “硬件指令集的发展” 才能进行呢？**因为我们需要操作和冲突检测这两个步骤具备原子性**，靠什么来保证呢？如果这里再使用互斥同步来保证就失去意义了，所以我们只能靠硬件来完成这件事情，**硬件保证一个从语法上看起来需要多次操作的行为只通过一条处理器指令就能完成，这类指令常用的有**：

*  测试并设置（Test-and-Set）。
 *  获取并增加（Fetch-and-Increment）。
 *  交换（Swap）。
 *  比较并交换（Compare-and Swap，下文成 CAS）。
 *  加载连接 / 条件存储（Load-Linked / Store-Conditional，下文称 LL/SC）。

其中，前面的 3 条是 20 世纪就已经存在于大多数指令集之中的处理器指令，后面的两条是现代处理器新增的，而且这两条指令的目的和功能是类似的。在 IA64、x86 指令集中有 cmpxchg 指令完成 CAS 功能，在 sparc-TSO 也有 casa 指令实现，而在 ARM 和 PowerPC 架构下，则需要使用一对 Idrex/strex 指令来完成 LL/SC 的功能。

CAS 指令需要有 3 个操作数，分别是**内存位置**（在 Java 中可以简单理解为变量的内存地址，用 V 表示）、**旧的预期值**（用 A 表示）和**新值**（用 B 表示）。CAS 指令执行时，当且仅当 V 符合旧值预期值 A 时，处理器用新值 B 更新 V 的值，否则它就不执行更新，**但是无论是否更新了 V 的值，都会返回 V 的旧值**，上述的处理过程是一个原子操作。

在 JDK 1.5 之后，Java 程序中才可以使用 CAS 操作，该操作由 sun.misc.Unsafe 类里面的 compareAndSwapInt() 和 compareAndSwapLong() 等几个方法包装提供，虚拟机在内部对这些方法做了特殊处理，即时编译出来的结果就是一条平台相关的处理器 CAS 指令，没有方法调用的过程，或者可以认为是无条件内联进去了。（注：这种被虚拟机特殊处理的方法称为**固有函数（intrinsics）**，类似的固有函数还有 Math.sin() 等）

**由于 Unsafe 类不是提供给用户程序调用的类（Unsafe.getUnsafe() 的代码中限制了只有启动类加载器（Bootstrap ClassLoader）加载的 Class 才能访问它，因此，如果不采用反射手段，我们只能通过其他的 Java API 来间接使用它**，如 J.U.C 包里面的整数原子类，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。

我们不妨拿一段在第 12 章(《深入理解java虚拟机》)中没有解决的问题代码来看看如何使用 CAS 操作来避免阻塞同步，代码如代码清单 12-1 所示。我们曾经通过这段 20 个线程自增 10000 次的代码来证明 volatile 变量不具备原子性，那么如何才能让它具备原子性呢？把 “race++” 操作或 increase() 方法用同步块包裹起来当然是一个办法，但是如果改成代码清单 13-4 所示的代码，那效率将会提高许多（实测效率更低~~）。

/**
     * Atomic 变量自增运算测试
     * 
     * @author yy
     */
    public class AtomicTest {
    	
    	public static AtomicInteger race = new AtomicInteger(0);
    	
    	public static void increase() {
    		race.incrementAndGet();
    	}
    	
    	private static final int THREADS_COUNT = 20;
    	
    	public static void main(String[] args) {
    		Thread[] threads = new Thread[THREADS_COUNT];
    		for (int i = 0; i < THREADS_COUNT; i ++) {
    			threads[i] = new Thread(new Runnable() {
    				@Override
    				public void run() {
    					for (int i = 0; i < 10000; i++) {
    						increase();
    					}
    				}
    			});
    			threads[i].start();
    		}
    		
    		// 等待所有累加线程都结束
    		while (Thread.activeCount() > 1) 
    			Thread.yield();
    		
    		System.out.println(race);
    	}
    }
    
    
    //结果：
    200000

使用 AtomicInteger 代替 int 后，程序输出了正确的结果，一切都要归功于 incrementAndGet() 方法的原子性。它的实现其实非常简单：

/**
         * Atomically increments by one the current value.
         *
         * @return the updated value
         */
        public final int incrementAndGet() {
            for (;;) {
                int current = get();
                int next = current + 1;
                if (compareAndSet(current, next))
                    return next;
            }
        }

incrementAndGet() 方法在一个无限循环中，不断尝试将一个比当前值大 1 的新值赋给自己。如果失败了，那说明在执行 “获取-设置” 操作的时候值已经有了修改，于是再次循环进行下一次操作，直到设置成功为止。

**尽管 CAS 看起来很美，但显然这种操作无法涵盖互斥同步的所有使用场景，并且 CAS 从语义上来说并不是完美的，存在这样的一个逻辑漏洞：如果一个变量 V 初次读取的时候是 A 值，并且在准备赋值的时候检查到它仍然为 A 值，那我们就能说它没有被其他线程改变过了吗？如果在这段期间它的值曾经被改成了 B，后来又被改回 A，那 CAS 操作就会误认为它从来没有被改变过。这个漏洞称为 CAS 操作的 “ABA” 问题。J.U.C 包为了解决这个问题，提供了一个带有标记的原子引用类 “AtomicStampedReference”，它可以通过控制变量值的版本来保证 CAS 的正确性。不过目前来说这个类比较 “鸡肋”，大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。**

### 3. 无同步方案 ###

要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的，笔者简单地介绍其中的两类。

**1）可重入代码**（Reentrant Code）：这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。

可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。

**2）** **线程本地存储**（Thread Local Storage）：如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。

符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如 “生产者 - 消费者” 模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典 Web 交互模型中的 “一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。

Java 语言中，如果一个变量要被多线程访问，可以使用 volatile 关键字声明它为 “易变的”；如果一个变量要被某个线程独享，Java 中就没有类似 C++ 中的 \_\_declspec(thread) （注：在 Visual C++ 是 “\_\_declspec(thread)” 关键字，而在 GCC 中是 “\_\_thread”）这样的关键字，不过还是可以通过 java.lang.ThreadLocal 类来实现线程本地存储的功能。每一个线程的 Thread 对象中都有一个 ThreadLocalMap 对象，这个对象存储了一组以 ThreadLocal.threadLocalHashCode 为键，以本地线程变量为值的 K-V 值对，ThreadLocal 对象就是当前线程的 ThreadLocalMap 的访问入口，每一个 ThreadLocal 对象都包含了一个独一无二的 threadLocalHashCode 值，使用这个值就可以在线程 K-V 值对中找回对应的本地线程变量。

\-----------------------------------------------------------------------------------------------------------------------------------------------------

# 二. 锁优化 #

高效并发是从 JDK 1.5 到 JDK 1.6 的一个重要改进，HotSpot 虚拟机开发团队在这个版本上花费了大量的精力去实现各种锁优化技术，如适应性自旋（Adaptive Spinning）、锁消除（Lock Elimination）、锁粗化（Lock Coarsening）、轻量级锁（Lightweight Locking）和偏向锁（Biased Locking）等。这些技术都是为了在线程之间更高效地共享数据，以及解决竞争问题，从而提高程序的执行效率。

### 1.自旋锁与自适应自旋 ###

**1.   问题：**前文中我们提到，互斥同步对性能最大的影响是阻塞的实现，挂起线程和恢复线程的操作都需要转入内核态中完成，这些操作给系统的并发性能带来了很大的压力。同时，虚拟机的开发团队也注意到在许多应用上，共享数据的锁定状态只会持续很短的一段时间，为了这段时间去挂起和恢复线程很不值得；（产生自旋锁与自适应自旋的背景）

**2.  自旋锁出现：**如果物理机器有一个以上的处理器，能让两个或以上的线程同时并行执行，我们就可以让后面请求锁的那个线程 “稍等一下”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只需让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。

**     2.1.   **jdk1.6中 自旋锁是默认开启的，可以使用 -XX:+UseSpinning 参数来开启；

**     2.2.  自旋等待的时间必须要有一定的限度：** 如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程了。自旋次数的默认值是10，用户可以用参数 -XX:PreBlockSpin 来更改；

**     2.3.   自适应自旋锁：**jdk1.6 中引入了自适应的自旋锁。自适应意味着自旋的时间不再固定了，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定；

**3.  例子**

**case1）**如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也很有可能再次成功，进而它将允许自旋等待持续相对更长的时间，比如100个cycle；

**case2）**如果对于某个锁，自旋很少成功获得过， 那在以后要获取这个锁时将可能省略掉自旋过程，以避免浪费处理器资源；

### **2. 锁消除** ###

**1.  定义：**锁消除是指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检查到不可能存在共享数据竞争的锁进行消除；

**2.  锁消除的主要判定依据：**来源于逃逸分析的数据支持；如果判定在一段代码中，堆上的所有数据都不会逃逸出去从而被其他线程访问到，那就可以把它们当做栈上数据对待，认为它们是线程私有的，同步加锁自然就无须进行了；

**3.  问题+解决**

**    3.1.  问题：**程序员自己应该很清楚，怎么会在明知道不存在数据争用的case下还要求同步呢？

**    3.2.  解决：**许多同步措施并不是程序员自己加入的，同步的代码在java程序中的普遍程度早就超过了大部分人的想象**（许多同步措施并不是程序员自己加入的）**；

**4.  例子：**下面这段代码仅仅是输出3个字符串相加的结果，无论是源码字面上还是程序语义上都没有同步；

public static String concatString(String s1, String s2, String s3) {
    	return s1 + s2 + s3;
    }

我们也知道，由于 String 是一个不可变的类，对字符串的连接操作总是通过生成新的 String 对象来进行的，因此 Javac 编译器会对 String 连接做自动优化。在 JDK 1.5 之前，会转化为 StringBuffer 对象的连续 append() 操作，在 JDK 1.5 及以后的版本中，会转化为 StringBuilder 对象的连续 append() 操作，即上面的代码可能会编程成下面代码的样子（注：客观地说，既然谈到锁消除与逃逸分析，那虚拟机就不可能是 JDK 1.5 之前的版本，实际上会转化为非线程安全的 StringBuilder 来完成字符串拼接，并不会加锁，但这也不影响笔者用这个例子证明 Java 对象中同步的普遍性）。

public static String concatString(String s1, String s2, String s3) {
    	StringBuffer sb = new StringBuffer();
    	sb.append(s1);
    	sb.append(s2);
    	sb.append(s3);
    	return sb.toString();
    }

**对以上代码的分析（Analysis）：**

**     A1）对于 javac 转化后的字符串连接操作代码：** 使用了同步，因为StringBuffer.append() 方法中都有一个同步块，锁就是sb对象。虚拟机观察变量sb，很快就会发现他的动态作用域被限制在 concatString() 方法内部；也就是所 sb 的所有引用都不会逃逸到方法之外；

**    A2）**所以，虽然这里有锁，但是可以被安全地消除掉，在即时编译之后，这段代码就会忽略掉所有的同步而直接执行了；

### 3.  锁粗化 ###

原则上，我们在编写代码的时候，总是推荐将同步块的作用范围限制得尽量小——只在共享数据的实际作用域中才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁竞争，那等待锁的线程也能尽快拿到锁。

大部分情况下，上面的原则都是正确的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁操作是出现在循环体中，那即使没有线程竞争，频繁地进行互斥同步操作也会导致不必要的性能损耗。

**所以锁粗化的定义：如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁同步的范围扩展（粗化）到整个操作序列的外部**，以上一小节最后一段代码为例（3个String相加），就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，这样只需要加锁一次就可以了。

### 4.  轻量级锁 ###

**1.   重量级锁定义：**使用操作系统互斥量来实现的传统锁；

**2.   轻量级锁的目的：**不是用来替代重量级锁，而是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗；

**3.   HotSpot虚拟机的对象头分为两部分信息：（干货——HotSpot虚拟机的对象头分为两部分信息）**

**       3.1    第一部分：**用于存储对象自身的运行时数据，如哈希码，GC分代年龄等；这部分数据的长度在32位和64位的虚拟机中分别为 32bit 和 64bit，官方称它为 Mark Word，它是实现轻量级锁和偏向锁的关键；**（干货——Mark Word 是实现轻量级锁和偏向锁的关键）**

**      3.2.   第二部分：**用于存储指向方法区对象类型数据的指针，如果是数组对象的话，还会有一个额外的部分用于存储数组长度；

**      3.3.   **对象头信息是与对象自身定义的数据无关的额外存储成本，考虑到虚拟机的空间效率，Mark Word 被设计成一个非固定的数据结构以便在极小的空间内存储尽量多的信息，它会根据对象的状态复用自己的存储空间；

**      3.4.   HotSpot 虚拟机对象头Mark Word 如下图所示：**

**![70][]**

**4.   在代码进入同步块的时候：**

**     4.1.   轻量级锁的加锁过程：（干货——轻量级锁的加锁过程）**

*  **step1：**在代码进入同步块的时候，如果此同步对象没有被锁定（锁标志位为01状态）：虚拟机首先将在当前线程的栈帧中建立一个名为 锁记录的空间，用于存储对象目前的Mark Word 的拷贝（官方把这份拷贝加了个前缀Displaced），这时线程堆栈与对象头的状态如图13-3所示；
 *  **step2：**然后，虚拟机将使用CAS 操作尝试将对象的 Mark Word 更新为指向 Lock Record的指针；
 *  **step3：**如果这个更新工作成功了，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位将转变为 00，即表示 此对象处于轻量级锁定状态，这时线程堆栈与对象头的状态如图13-4所示；
 *  **step4：**如果这个更新失败了，虚拟机首先会检查对象的Mark Word 是否指向当前线程的栈帧，如果只说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行，否则说明这个锁对象以及被其他线程抢占了。**如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁，锁标志的状态值变为 10**，Mark Word中存储的就是指向重量级（互斥量）的指针，后面等待锁的线程也要进入阻塞状态；

![70 1][]

**     4.2.  轻量级锁的解锁过程：（干货——轻量级锁的解锁过程，其解锁过程也是通过CAS 操作来进行的）**

*  **step1：**如果对象的Mark Word仍然指向着线程的锁记录，那就用CAS 操作把对象当前的Mark Word 和 线程中复制的 Dispatched Mard Word替换回来；
 *  **step2：**如果替换成功，整个同步过程就over了；
 *  **step3：**如果替换失败，说明有其他线程尝试过获取该锁，那就要在释放锁的同时，唤醒被挂起的线程；

**Conclusion:**

*  **C1：轻量级锁能提升程序同步性能的依据是：** 对于绝大部分的锁，在整个同步周期内都是不存在竞争的；
 *  **C2：如果没有竞争，轻量级锁使用CAS 操作避免了使用互斥量的开销；**但如果存在锁竞争，除了互斥量的开销外，还额外发生了CAS 操作，因此在有竞争的case下， 轻量级锁会比传统的重量级锁更慢；

### **5.   偏向锁** ###

**1.   目的：**消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能；

**2.   定义：如果说轻量级锁是在无竞争的情况使用CAS 操作去消除同步使用的互斥量：**那偏向锁就是在无竞争的情况下把整个同步都消除掉，连CAS 操作都不做了；

**3.   偏向锁的偏：** 它的意思是这个锁会偏向于 第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步；

**4.   偏向锁的原理：**若当前虚拟机启用了偏向锁，那么，当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志位设为01， 即偏向模式；同时使用CAS 操作把获取到这个锁的线程的ID 记录在对象的 Mark Word之中，如果 CAS操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行任何同步操作；

**5.   当有另一个线程去尝试获取这个锁时，偏向模式就结束了：**根据锁对象目前是否处于被锁定的状态， 撤销偏向后恢复到未锁定（标志位为01）或轻量级锁定（标志位为00）的状态，后续的同步操作就如上面介绍的轻量级锁那样执行；

**Conclusion：**

**C1）**偏向锁可以提高带有同步但无竞争的程序性能；

**C2）**如果程序中大多数的锁总是被多个不同的线程访问：那偏向模式是多余的；

![70 2][]

# 三.  悲观锁与乐观锁 #

首先我们要知道一个概念：Java中的锁是对象级别的概念, 也就是每个对象都天生可以作为一个锁使用.（类也可以作为锁）

实际上锁是存在于java头对象的MarkWord字段里一个2bit的锁标识位，来区分所得锁的级别和存储结构等信息。

可以分为悲观锁和乐观锁，下面我们就来看看这两种锁。

# #

### 1.  悲观锁 ###

悲观锁是**`synchronize`**内部的实现机制, java 1.6之后, 对悲观锁进行了改进, 也就是现在不是所有同步操作都一定会被阻塞. 如今的悲观锁按照锁的获取与释放方式被划分为**偏向锁, 轻量级锁, 重量级锁**. 锁标识位分别为01, 00, 10. 这几种状态会随着锁的竞争情况逐渐升级(但是不会降级)

**1.偏向锁（见上一节）**

**偏向锁是一种出现竞争才释放锁的机制**.具体来说, 作为锁的对象头部会保存一个`偏向锁标识`, 存储当前获得锁的线程ID. 假设当前是线程A获得了锁, 但是线程A执行完同步块之后并不释放锁, 而是等到其他线程竞争之后才进行锁的释放. 为什么要这样设计呢? 因为如果下次还是线程A来访问同一同步块, 那么就无需通过CAS操作来重新对锁对象的对象头进行更新, 简单比对一下线程id是否相等即可.

**2.轻量级锁（见上一节）**

**       当偏向锁的撤销与获取经常出现的时候(也就是锁的竞争经常发生的时候), 就会升级为轻量级锁.**线程通过CAS获取轻量级锁的方法与获取偏向锁的过程不同, 它总是将锁对象的Markword先拷贝到栈空间, 然后试图通过CAS更新Markword, 如果成功说明获得了锁, 如果失败说明其他线程成功更新了Markword(也就是获得了锁), 则通过自旋CAS尝试重新获取锁(始终消耗CPU时间片), 如果在较短的时间内成功, 则锁不会升级, 如果长时间未获得锁, 则锁会升级到重量级锁.

**3.重量级锁**

重量级锁在线程获得锁失败时不会进行自旋CAS尝试重新获取锁, 而是会进入阻塞态(让出CPU时间片, 在其他线程释放锁后由CPU调度重新进行锁竞争).

**小结**

三种锁并没有好坏之分, 分别有各自适用的场合:

<table> 
 <tbody> 
  <tr> 
   <td>锁</td> 
   <td>优点</td> 
   <td>缺点</td> 
   <td>适用场景</td> 
  </tr> 
  <tr> 
   <td>偏向锁</td> 
   <td>在没有锁竞争的情况下, 加锁极快, 且无需解锁</td> 
   <td>如果较多线程竞争锁, 会使得加解锁的过程额外费时</td> 
   <td>长时间一个线程访问同步块的场景</td> 
  </tr> 
  <tr> 
   <td>轻量级锁</td> 
   <td>竞争线程不会阻塞, 响应快</td> 
   <td>如果长时间无法获得锁, 自旋CAS会带来较大的CPU开销</td> 
   <td>追求响应时间, 且同步块执行速度块的场景</td> 
  </tr> 
  <tr> 
   <td>重量级锁</td> 
   <td>线程无法获取锁时总是阻塞, 及时让出CPU资源</td> 
   <td>线程阻塞, 需要通过调度重新竞争锁, 响应缓慢</td> 
   <td>追求高吞吐量, 且同步块执行时间较长的场景, 如包含大量I/O操作</td> 
  </tr> 
 </tbody> 
</table>

![70 3][]

![70 4][]

### 2. 乐观锁 ###

**乐观锁允许所有的线程在不发生阻塞的情况下创建一份共享内存的拷贝. 这些线程接下来可能会对它们的拷贝进行修改，并企图把它们修改后的版本通过CAS操作写回到共享内存**. 如果, 另一个线程已经修改了共享内存, 这个线程将不得不再次获得一个新的拷贝, 在新的拷贝上做出修改, 并尝试再次通过CAS把它们写回到共享内存中去

称之为”乐观锁”的原因就是, 线程获得它们想修改的数据的拷贝并做出修改, 乐观的假设在此期间没有其他线程对共享内存做出修改, 当这个乐观假设成立时, 这个线程仅仅在无锁的情况下完成共享内存的更新. 当这个假设不成立时, 线程所做的工作就会被丢弃。无论乐观假设成功或者失败, 乐观锁总是没有使用锁进行并发的控制

** 乐观锁仅适用于共享内存竞用不是非常高的情况.如果共享内存上的需要修改的内容非常多, 那么会因为CAS更新共享内存失败, 从而浪费大量的CPU周期用在重新拷贝和修改上.**

这篇文章写得好

[https://blog.csdn.net/a314773862/article/details/54095819][https_blog.csdn.net_a314773862_article_details_54095819]

[70]: /images/20220515/6cbb65309f8a47eb8f25b3697ebcc7c6.png
[70 1]: /images/20220515/1d20086d3c674f4a99ce130c66526989.png
[70 2]: /images/20220515/56628fe2cbcf49dbbe0d756dad6d57ac.png
[70 3]: /images/20220515/fcb9802ec2a34f17981e0e84b167478d.png
[70 4]: /images/20220515/3356da667ee6454799cd699c13aa8dcb.png
[https_blog.csdn.net_a314773862_article_details_54095819]: https://blog.csdn.net/a314773862/article/details/54095819