2024年最全Java面试-锁的内存语义_锁获取的内存语义(2)，2024年最新前端移动端开发面试题

2301_82243839

于 2024-05-14 08:39:22 发布

阅读量898

点赞数 20

分类专栏：程序员文章标签：前端面试学习

本文链接：https://blog.csdn.net/2301_82243839/article/details/138835952

版权

程序员专栏收录该内容

93 篇文章 0 订阅

订阅专栏

对象篇

模块化编程-自研模块加载器

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

int a = 0;

public synchronized void writer() {     // 1;
    a++;                                // 2;
}                                       // 3;

public synchronized void reader() {     // 4;
    int i = a;                          // 5;
    System.out.println(i);
}                                       // 6;

}


假设线程A执行writer()方法，随后线程B执行reader()方法。根据happens-before规范，这个过程包含的happens-before关系可以分为3类。


1. 根据程序次序规则：1 happens-before 2，2 happens-before 3, 4 happens-before 5，5 happens-before 6
2. 根据监视器锁规则：3 happens-before 4
3. 根据happens-before的传递性，2 happens-before 5


  
 上述happens-before关系的图形化表现形式如图：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210611002724407.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5,size_16,color_FFFFFF,t_70#pic_center)


**总结：**  
 线程A在释放锁之前所有可见的共享变量，在线程B获取同一个锁之后，将立即变得对B线程可见。  
 


#### 2、锁释放和获取的内存语义


当线程释放锁时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。以上述MonitorExample程序为例，A线程释放锁后，共享数据的状态示意图如下所示：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210611002746606.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5,size_16,color_FFFFFF,t_70#pic_center)



**共享数据的状态示意图**


当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器锁保护的临界区代码必须从主内存中读取共享变量。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210611002832452.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5,size_16,color_FFFFFF,t_70#pic_center)  
 



**锁获取的状态示意图**


对比锁释放-获取锁的内存语义与volatile写-读的内存语义可以看出：锁释放与volatile写有相同的内存语义；锁获取与volatile读有相同的内存语义。  
 **总结：**


* 线程A释放锁，实质上是线程A向接下来要获取这个锁的某个线程发出了（线程A对共享变量所做修改的）消息。
* 线程B获取锁，实质上是线程B接受了之前某个线程发出的（在释放这个锁对共享变量锁做的修改的）消息。
* 线程A是否锁，随后线程B获取这个锁，这个**过程实质上是线程A通过主内存向线程B发送消息**。


  

#### 3、锁内存的语义实现


分析ReentrantLock的源代码，来分析锁内存语义的具体实现机制。  
 示例代码：

package com.lizba.p1;

import java.util.concurrent.locks.ReentrantLock;

/**
*

* ReentrantLock示例代码
*

*
* @Author: Liziba
* @Date: 2021/6/10 22:17
*/
public class ReentrantLockExample {

int a = 0;
ReentrantLock lock = new ReentrantLock();

public void writer() {
    lock.lock();                 // 获取锁
    try {
        a++;
    } finally {
        lock.unlock();          // 释放锁
    }
}

public void reader() {
    lock.lock();                // 获取锁
    try {
        int i = a;
        System.out.println(i);
    } finally {
        lock.unlock();          // 释放锁
    }
}

}


在ReentrantLock中，调用lock()方法获取锁；调用unlock()方法释放锁。  
 ReentrantLock的实现依赖于Java同步器框架AbstractQueuedSynchronized(AQS)。AQS使用一个整型的volatile变量（state）来维护同步状态，这个volatile变量是ReentrantLock内存语义实现的关键。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210611002916948.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTI1MjE5,size_16,color_FFFFFF,t_70#pic_center)



**ReetrantLock的类图**


**ReentrantLock分为公平锁和非公平锁，首先分析公平锁。**  
 使用公平锁时，加锁方法lock()的调用轨迹如下。


1. ReentrantLock: lock()
2. FairSync: lock()
3. AbstractQueuedSynchronizer: acquire(int arg)
4. ReentrantLock: tryAcquire(int acquires)


第4步开始真的加锁，下面是该方法的源代码：

protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 获取锁开始，首先读取volatile变量state
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error(“Maximum lock count exceeded”);
setState(nextc);
return true;
}
return false;
}


从上面的代码中可以看出，加锁方法首先读取volatile变量state。  
 


在使用公平锁时，解锁方法unlock()调用轨迹如下：


1. ReentrantLock: unlock()
2. AbstractQueuedSynchronizer: release(int arg)
3. Sync: tryRelease(int release)


第3步开始真的释放锁，下面是该方法的源代码：

protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
// 释放锁的最后，写volatile变量state
setState©;
return free;
}


从上面的代码中可以看出，释放锁的最后写volatile变量state。  
 **总结公平锁：**  
 根据volatile的happens-before规则，释放锁的线程在写volatile变量之前可见的共享变量，在获取锁的线程读取到同一个volatile变量后将立即变得对获取锁的线程可见。  
 


**现在分析非公平锁：**  
 注意，非公平锁的释放和公平锁的释放完全一致，都是上面的源代码。所以下面只分析非公平锁的获取过程。  
 


使用非公平锁，加锁方法lock()的调用轨迹如下：


1. ReentrantLock: lock()
2. NonfairSync: lock()
3. AbstractQueuedSynchronizer: compareAndSetState(int expect, int update)


第3步开始真的加锁，下面是该方法的源代码：

// 方法1
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 此方法中开始加锁
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;

总结

秋招即将开始，校招的朋友普遍是缺少项目经历的，所以底层逻辑，基础知识要掌握好！

而一般的社招，更是神仙打架。特别强调，项目经历不可忽视；几乎简历上提到的项目都会被刨根问底，所以项目应用的技术要熟练，底层原理必须清楚。

这里给大家提供一份汇集各大厂面试高频核心考点前端学习资料。涵盖 HTML，CSS，JavaScript，HTTP，TCP协议，浏览器，Vue框架，算法等高频考点238道（含答案）！

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

资料截图：

高级前端工程师必备资料包

2301_82243839

关注

20
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
2024年最全Java面试-锁的内存语义_锁获取的内存语义(2)，2024年最新前端移动端开发面试题

秋招即将开始，校招的朋友普遍是缺少项目经历的，所以底层逻辑，基础知识要掌握好！而一般的社招，更是神仙打架。特别强调，项目经历不可忽视；几乎简历上提到的项目都会被刨根问底，所以项目应用的技术要熟练，底层原理必须清楚。这里给大家提供一份汇集各大厂面试高频核心考点前端学习资料。涵盖HTML，CSS，JavaScript，HTTP，TCP协议，浏览器，Vue框架，算法等高频考点238道（含答案）！开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】高级前端工程师必备资料包。
复制链接

扫一扫