【Java锁体系】五、隐式锁和显式锁的区别(Synchronized和Lock的区别)

最新推荐文章于 2024-05-26 11:30:39 发布
原创 最新推荐文章于 2024-05-26 11:30:39 发布 · 788 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java隐式锁 #java显式锁 #显式锁和隐式锁 #synchronized #lock

本文聚焦Java并发编程中隐式锁和显式锁的区别。隐式锁以synchronized为代表，由JVM维护；显式锁以Lock为代表，是JDK5后出现的类。文章从出身、使用方式、等待是否中断、加锁公平性、锁绑定条件及性能等方面进行了详细对比。

目录：

【Java锁体系】一、悲观锁和乐观锁

【Java锁体系】二、Java中的CAS机制算法

【Java锁体系】三、自旋锁详解

【Java锁体系】四、Synchronized关键字详解

【Java锁体系】五、隐式锁和显氏锁的区别(Synchronized和Lock的区别)

【Java锁体系】六、AQS原理分析(AbstractQueuedSynchronizer实现分析)

【Java锁体系】七、JMM内存模型详解

【Java锁体系】八、MESI缓存一致性协议讲解

【Java锁体系】九、volatile关键字

【Java锁体系】五、隐式锁和显式锁的区别(Synchronized和Lock的区别)

在Java并发编程中，Java中隐式锁有synchronized，显式锁有Lock。

1.两者的出身不同

synchronized是Java中的关键字，由JVM维护，是JVM层面的锁；

而lock是JDK5之后才出现的具体的类，使用Lock是调用对应的API，是API层面的锁。

synchronized的底层是通过monitorenter进行加锁的（底层是通过monitor对象来完成的，其中的wait/notify等方法也是依赖monito对象的，只有在同步块或者是同步方法中才可以调用wait/notify方法。因为只有在同步块或同步方法中，JVM才会调用monitor对象的。）；通过monitorexit来退出锁的。

Lock则是通过调用相应的API方法来获取和释放锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GSkVVUQw-1608212002139)(D:\software\typora\workplace\imgs_cas\27.jpg)]

2.使用方式的不同

synchronized隐式锁；lock是显式锁

显氏锁和隐式锁的区别在于：使用显式锁的时候，使用者需要手动去获取和释放锁。

在使用synchronized关键字的时候，使用者不需要写其他的代码，程序就可以自动获取锁和释放锁。synchronized是由系统维护的，系统会自动的让程序释放占用的锁。

在使用lock的时候，需要使用者手动去获取锁和释放锁。如果没有释放锁，就可能出现死锁的现象。手动获取锁的方法lock.lock(); 释放锁的操作：unlock().

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EhpupxQg-1608212002141)(D:\software\typora\workplace\imgs_cas\28.png)]

3.等待是否中断

synchronized关键字是不可中断的，除非抛出异常或者正常运行结束

而Lock是可以中断的，中断方式：

  • 调用设置超时方法tryLock(Long timeout,timeUnit unit)
  • 调用lockInterruptibly()放到代码块中，然后调用interrupt()方法可以中断。

4.加锁的时候是否公平

synchronized是非公平锁；

而lock两者都可以，默认创建是非公平锁。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dK4j6BIw-1608212002143)(D:\software\typora\workplace\imgs_cas\29.png)]

5.锁绑定多个条件来condition

synchronized要么随机唤醒一个线程；要么是唤醒所有等待的线程。

lock：可以用实现分组唤醒需要唤醒的线程，可以精准的唤醒，而不是像synchronized那样，不能精准唤醒线程。

6.性能比较

synchronized是托管给JVM去执行的，而Lock是Java写的控制锁的代码。在Java1.5中，synchronized的性能是低效的，因为其是重量级锁的操作，需要从用户态切换到内核态消耗大量的时间。相比之下使用Java提供的Lock对象，性能更高一些。但是到了Java1.6之后，对synchronized关键字进行了优化，有适应性自旋，锁消除，轻量级锁，偏向锁等，导致在Java1.6中synchronized的性能并不比lock差。

在之前的synchronized版本中使用是悲观锁的机制，即线程独占锁，其它线程只能依靠阻塞来等待线程释放的锁，而线程阻塞时会引起线程的上下文切换，当有很多线程竞争锁的时候，会引起CPU频繁的上下文切换导致效率很低。

而Lock使用的乐观锁的方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁的实现方式就CAS机制(compareAndSetstate)，调用的是CPU提供的底层指令。

显式锁与隐式锁（Java）
技术小白
07-16 348
同步代码块和同步方法搜属于隐式锁 显式锁Lock 子类 ReentrantLock
Java多线程显式锁与隐式锁的不一样的详细解读
没完没了就好的博客
07-25 676
显示锁与隐式锁前言线程安全什么是线程安全？源码案例解释解决线程安全问题方法1、隐式锁：同步代码块2、隐式锁：同步方法3、显式锁:Lock总结 前言 那我在搜索多线程有关于锁的知识的时候发现，基本上所有的博客内容都是出自同一篇文章，啊，知识就是这样传播开来的。那我就觉得我既然也学习了这个知识点那就做点不一样的，当然我也很希望大家都能转载我这篇博客，留言说一声就行，点个赞再走也不错，能收藏那就是极好不过了，不转载学习讨论留言评论区大家一起探讨也是极好的。 好，开始我们的学习，那在开始本次的学习中我希望大家能够了
synchronized 和 Lock 的区别是什么
八戒的博客
05-26 1835
synchronized 和 Lock 都是Java 中用来解决线程安全问题的工具,关于 synchronized 和 Lock的区别，可以从以下4个方面来给大家做一个详细的分析。
Java并发之显式锁和隐式锁的区别
凯哥Java的博客
04-16 1170
Java并发之显式锁和隐式锁的区别 在面试的过程中有可能会问到：在Java并发编程中，锁有两种实现：使用隐式锁和使用显示锁分别是什么？两者的区别是什么？所谓的显式锁和隐式锁的区别也就是说说Synchronized(下文简称：sync)和lock(下文就用ReentrantLock来代之lock)的区别。 本文主要内容：将通过七个方面详细介绍sync和lock的区别。通过生活case中...
显式锁与隐式锁的区别
Shalick的书架
10-19 1315
显式锁与隐式锁的区别 解决的方法 格式 描述 同步代码块(关键字) synchronized(锁对象){} 隐式锁，多个线程的锁对象必须唯一 同步方法(修饰符) synchronized 返回类型 方法名(){} 隐式锁，谁调用该方法谁就是锁对象 显示锁 ReentrantLock类的lock()/unlock()方法 显式锁，有程序员决定在那开启/关闭锁 一、构成不同 Sync 和 Lock 的出身（原始的构成）不同： Sync：Java中的关键字，是由JVM来维护的。是J
【线程安全】【线程通信】【Java】synchronized锁讲解，锁方法和锁住变量，隐式锁和显式锁Lock，信息同步
m0_46716894的博客
10-29 1108
【线程安全】【线程通信】【Java】synchronized锁讲解，锁方法和锁住变量，隐式锁和显式锁Lock，信息同步
精选资源
lock锁，lock锁和synchronized的对比
11-19
Lock是显式锁，需要手动的开启和关闭，synchronized锁是隐式锁，只要出了作用域就会自动释放。Lock只有代码块锁，synchronized既有代码块锁还有方法锁。 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。有...
Java多线程之显示锁和内置锁总结详解
08-28
总结来说，Java多线程中的内置锁和显式锁各有优劣。内置锁简洁易用，但控制有限；显式锁提供了更多灵活性，但使用起来相对复杂。根据具体应用场景选择合适的锁机制，能有效提高并发程序的性能和可维护性。
隐式锁与显示锁的区别
ZL_do_it的博客
05-11 766
隐式锁与显示锁的区别 定义 隐式锁（Synchronized）是Java的关键字，当它用来修饰一个方法或一个代码块时，能够保证在同一时刻最多只有一个线程执行该代码。因为当调用Synchronized修饰的代码时，并不需要显示的加锁和解锁的过程，所以称之为隐式锁。 显示锁（Lock）是一个接口，提供了无条件的、可轮询的、定时的、可中断的锁获取操作，所有的加锁和解锁操作方法都是显示的，因而称为显示锁。 区别 1.出身不同 Synchronized：Java中的关键字，是由IVM来维护的，是JVM层面的锁
隐式锁与显式锁
西北的博客
03-02 1101
文章目录一、隐式锁1、同步代码块2、同步方法二、显示锁Lock三、区别1、实现方式2、是否公平3、灵活性4、内存泄漏5、使用方式6、是否可中断7、精确唤醒四、共同点 一、隐式锁 隐式锁中又分为同步代码块和同步方法,但是都是基于Synchronized关键字来实现的,因为他只需要是使用管关键字就可以,不用显示加锁和解锁的过程,所以称之为隐式锁。 1、同步代码块 在代码块前面加上Synchroized关键字,并在后面的小括号内传入锁对象,这里的this是指定了当前的这个对象作为锁,注意任何对象都是可以作为锁来使
Java显式锁和隐式锁的区别
weixin_46623319的博客
03-23 302
Java线程不安全问题有三种解决方案 那所谓显式锁和隐式锁即Lock和synchronized的区别。 一、构成不同 ->Sync：Java中的关键字，是由JVM来维护的，是JVM层面的锁。 Sync 底层是通过 monitorenter 进行加锁（底层是通过 monitor 对象来完成的，其中的wait/notify等方法也 是依赖于 monitor 对象的。只有在同步代码块或者同步方法中才可以调用wait/notify等方法。因为只有在同步代码块或者是同步方法中，JVM才会调用 monitor
Java锁机制——隐式锁和显式锁的区别
旅程的点点滴滴
05-09 306
概述 Java技术中的锁机制是高并发采用多线程编程中的非常重要一环，用于解决资源竞争问题。 Java 中的并发锁大致分为隐式锁和显式锁两种。隐式锁就是我们最常使用的 synchronized 关键字，显式锁主要包含两个接口：Lock 和 ReadWriteLock，主要实现类分别为 ReentrantLock 和 ReentrantReadWriteLock，这两个类都是基于 AQS(AbstractQueuedSynchronizer) 实现的。 CAS（Compare and swap）比较和替换是设计
Java中显示锁与隐式锁的区别
weixin_48891324的博客
02-09 510
显示锁（synchronized）和隐式锁（lock）
隐式锁 Synchronized 与显示锁 Lock的用法和简单对比
x
03-12 5458
SynchronizedSynchronized是Java的关键字，当它用来修饰一个方法或一个代码块时，能够保证在同一时刻最多只有一个线程执行该代码。因为当调用Synchronized修饰的代码时，并不需要显示的加锁和解锁的过程，所以称之为隐式锁。Sychronized的用法：1、同步方法体，在方法声明中使用，如下：public synchronized void method(){
隐式锁与显式锁详细对比
windhua的博客
06-15 384
synchronized修饰的对象,该对象就是隐式锁,例子如下 public static void main(String[] args) { Runnable run = new Ticket(); new Thread(run).start(); new Thread(run).start(); new Thread(run).start(); new Thread(run).start(); } stat
隐式(Synchronized)锁和显式(java.util.Lock)锁
zbuger的博客
03-08 1203
隐式(Synchronized)锁和显式(java.util.Lock)锁 为了控制多个线程按照正确的顺序来访问共享数据,Java提供了提供了两种锁方案 1.隐式锁(Synchronized)   这一种就是比较大家熟悉的synchronized关键字,因为Java中每个对象都实现了lock的功能,所以synchronized正是利用了这一特性,来控制并发访问.使用synchroni
Java显示锁和隐式锁的区别
weixin_51602832的博客
10-10 331
显示锁lock和隐式锁synchronized的区别 一、使用方式不同 synchronized： 程序能够自动获取锁和释放锁。Sync是由系统维护的，如果非逻辑问题的话话，不会出现死锁。 Lock： 需要手动的获取和释放锁。如果没有释放锁，就有可能导致出现死锁的现象。 手动获取锁方法：lock.lock()。释放锁：unlock方法。并且需要配合tyr/finaly语句块来完成。 二、等待是否可以中断 synchronized 不可中断，一般都是等程序运行完成后才能结束，除非你抛出了.
显示锁（synchronized）与隐式锁（lock）的区别
cmyperson的博客
07-10 715
简单明了的了解下隐式锁和显示锁
synchronized和Lock锁有什么区别？
最新发布
08-19
<think>我们被要求比较Java中synchronized和Lock接口的差异。根据提供的引用，我们可以从多个维度进行对比：实现机制、功能特性、性能、使用方式等。下面将系统性地整理这些差异。 ### 1. **实现机制** - **synchronized**： - 是Java语言内置的关键字，属于JVM层面的锁实现。 - 依赖于JVM的监视器（Monitor）机制，每个对象都与一个Monitor关联。 - 通过字节码指令`monitorenter`（获取锁）和`monitorexit`（释放锁）实现[^5]。 - **Lock**： - 是一个接口（`java.util.concurrent.locks.Lock`），属于API层面的锁。 - 需要显式地通过其实现类（如`ReentrantLock`）来创建锁对象。 - 锁的获取和释放完全由代码控制[^3]。 ### 2. **功能特性** | **特性** | **synchronized** | **Lock** | |------------------|------------------------------------------|---------------------------------------------| | **可重入性** | 支持（同一线程可重复获取锁） | 支持（如`ReentrantLock`） | | **公平性** | 非公平锁（默认） | 可选择公平锁或非公平锁（通过构造参数） | | **中断响应** | 不支持锁等待中断 | 支持`lockInterruptibly()`方法实现中断响应 | | **超时机制** | 不支持 | 支持`tryLock(long time, TimeUnit unit)` | | **条件队列** | 通过`wait()`/`notify()`实现单一条件 | 支持多个条件（`Condition`对象） | | **锁绑定** | 锁与对象或类绑定 | 锁可独立于对象存在 | ### 3. **性能表现** - **历史演变**： - 早期JDK中，synchronized是重量级锁，性能较差（涉及用户态到内核态的切换）。 - JDK 1.6后，synchronized引入了**锁升级机制**（偏向锁→轻量级锁→重量级锁），性能大幅提升[^1][^4]。 - **Lock**： - 通常基于CAS（Compare-And-Swap）实现，减少上下文切换。 - 在高度竞争场景下，Lock的性能可能优于synchronized（如`ReentrantLock`的公平锁模式）[^1]。 ### 4. **使用方式** - **synchronized**： - 使用简单，无需手动释放锁（JVM自动管理）。 - 三种应用方式： 1. 修饰实例方法（锁当前对象）： ```java public synchronized void method() { ... } ``` 2. 修饰静态方法（锁当前类的Class对象）： ```java public static synchronized void method() { ... } ``` 3. 修饰代码块（指定锁对象）： ```java synchronized (obj) { ... } ``` - **Lock**： - 需要显式加锁和解锁（必须放在`try-finally`中确保解锁）： ```java Lock lock = new ReentrantLock(); lock.lock(); try { // 临界区代码 } finally { lock.unlock(); // 必须手动释放锁 } ``` - 提供更灵活的方法： - `tryLock()`：尝试非阻塞获取锁。 - `lockInterruptibly()`：可中断地获取锁。 ### 5. **锁的释放** - **synchronized**： - 自动释放：当线程执行完同步代码块或方法时，JVM自动释放锁；若线程异常退出，锁也会自动释放。 - **Lock**： - 必须手动调用`unlock()`释放锁，否则会导致死锁。 - 通常将解锁操作放在`finally`块中确保执行[^3]。 ### 6. **适用场景** - **synchronized**： - 适合简单的同步场景（如单条件同步）。 - 代码简洁性要求高的场景（减少样板代码）[^1][^2]。 - **Lock**： - 需要高级功能的场景（如可中断锁、超时锁、公平锁）。 - 需要多个条件变量（`Condition`）的复杂同步逻辑[^1][^4]。 ### 总结对比表 | **维度** | **synchronized** | **Lock** | |------------------|------------------------------------------|---------------------------------------------| | **实现层面** | JVM内置 | API接口实现 | | **锁释放** | 自动释放 | 手动释放（必须写`unlock()`） | | **中断响应** | 不支持 | 支持 | | **公平锁** | 仅非公平 | 可配置公平/非公平 | | **条件队列** | 单一条件 | 支持多个条件（`newCondition()`） | | **代码复杂度** | 简单（语法糖） | 复杂（需`try-finally`块） | | **性能趋势** | JDK 1.6后优化，多数场景够用 | 高竞争场景可能更优 | > **建议**： > - 优先使用`synchronized`：满足需求时首选（简洁安全）。 > - 需要高级功能时选`Lock`：如超时控制、公平锁等[^1][^2]。 --- ### 相关问题 1. Java中如何实现锁的公平性与非公平性？ 2. 什么是CAS操作？它在锁实现中起什么作用？ 3. synchronized的锁升级过程是怎样的？ 4. 如何使用Condition实现多条件同步？ 5. 读写锁（ReentrantReadWriteLock）与普通锁有何区别？ [^1]: synchronized与Lock的性能对比与应用场景 [^2]: synchronized和Lock的区别总结 [^3]: Lock接口的结构特性 [^4]: 读写锁的互斥规则 [^5]: synchronized的底层原理</think>### Java中synchronized与Lock锁的深度对比 #### 一、**本质区别** | **维度** | **synchronized** | **Lock** | |------------------|------------------------------------------|---------------------------------------------| | **实现层级** | JVM内置关键字（语言级特性） | Java API接口（`java.util.concurrent.locks`） | | **锁释放机制** | 自动释放（代码块结束/JVM管理）[^3] | 手动释放（必须显式调用`unlock()`）[^3] | | **实现原理** | 基于对象监视器（Monitor）和字节码指令`monitorenter/monitorexit`[^5] | 基于AQS（AbstractQueuedSynchronizer）队列实现 | #### 二、**功能特性对比** 1. **锁获取方式** - `synchronized`：**不可中断**（线程阻塞时会一直等待） - `Lock`：支持`lockInterruptibly()`实现**可中断锁**（响应线程中断信号）[^1] 2. **公平性控制** - `synchronized`：**仅支持非公平锁** - `Lock`：可配置公平/非公平锁（通过`ReentrantLock(true)`实现公平锁）[^1] 3. **条件变量** - `synchronized`：依赖`wait()/notify()`实现**单一条件队列** - `Lock`：通过`newCondition()`创建**多个条件变量**（如生产者和消费者独立等待队列）[^1] 4. **尝试锁机制** - `synchronized`：无超时机制 - `Lock`：支持`tryLock()`和`tryLock(long timeout, TimeUnit unit)`实现**限时等待**[^4] #### 三、**性能演变** | **JDK版本** | **synchronized优化** | **Lock特性** | |------------|------------------------------------------|-----------------------------------------| | ≤1.5 | 重量级锁（性能差） | 基于CAS的轻量级实现（性能优势明显） | | ≥1.6 | 引入锁升级：无锁→偏向锁→轻量级锁→重量级锁[^1] | 保持稳定，高竞争场景仍具优势 | | ≥1.8 | 继续优化逃逸分析等机制 | 读写锁分离（`ReentrantReadWriteLock`）[^4] | > 💡 **性能建议**： > - 低竞争场景：优先用`synchronized`（JVM自动优化） > - 高竞争/复杂场景：用`Lock`（如需要公平锁或条件变量）[^1] #### 四、**代码实践对比** 1. **synchronized基础用法** ```java // 对象锁 public synchronized void syncMethod() { // 临界区代码 } // 类锁 public static synchronized void staticSyncMethod() { // 临界区代码 } // 代码块锁 public void blockSync() { synchronized(this) { // 锁对象可自定义 // 临界区代码 } } ``` 2. **Lock高级用法** ```java Lock lock = new ReentrantLock(); // 默认非公平锁 Condition condition = lock.newCondition(); public void lockExample() { lock.lock(); // 必须手动加锁 try { if (conditionNotMet) { condition.await(); // 释放锁并等待 } // 临界区代码 condition.signalAll(); // 唤醒等待线程 } finally { lock.unlock(); // 必须放在finally块 } } ``` #### 五、**适用场景推荐** | **场景** | **推荐方案** | **原因** | |-----------------------------|----------------------|------------------------------------------| | 简单同步（如计数器递增） | `synchronized` | 代码简洁，JVM自动优化[^2] | | 需要公平性（如订单处理） | `ReentrantLock(true)`| 避免线程饥饿问题[^1] | | 读写分离（如缓存系统） | `ReentrantReadWriteLock` | 读操作完全并行，写操作互斥[^4] | | 复杂条件等待（如线程池调度） | `Lock`+`Condition` | 多条件队列控制更灵活[^1] | > ⚠️ **风险提示**： > 使用`Lock`时必须用`try-finally`保证解锁，否则会导致**死锁**（忘记`unlock()`的概率远高于`synchronized`自动释放）[^3]。 #### 六、**设计哲学差异** - **synchronized**：体现Java的**隐式锁哲学**（“锁即对象”），简化开发但灵活性受限。 - **Lock**：体现**显式锁哲学**（“锁是独立资源”），通过API暴露控制细节，适合复杂场景[^3]。 --- ### 相关问题 1. 如何通过`ReentrantReadWriteLock`实现高性能缓存？ 2. synchronized的锁升级过程具体如何运作？ 3. 什么是AQS（AbstractQueuedSynchronizer）？它在Lock中起什么作用？ 4. 如何诊断和解决Java中的死锁问题？ 5. 无锁编程（如CAS）与Lock/synchronized有何本质区别？ [^1]: synchronized与Lock的性能对比与应用场景 [^2]: synchronized和Lock的基础区别 [^3]: Lock接口的结构特性与设计哲学 [^4]: 读写锁的互斥规则 [^5]: synchronized的底层实现原理
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

mind_programmonkey

你的鼓励是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值