同步锁synchronized追溯本源

最新推荐文章于 2023-04-24 22:03:22 发布
最新推荐文章于 2023-04-24 22:03:22 发布
阅读量281 收藏 1
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48576969/article/details/115824289
版权

同步锁synchronized追溯本源

概念

synchronized：是Java中的关键字，是一种同步锁。

Java中锁分为以下几种：
乐观锁、悲观锁(syn)
独享锁(syn)、共享锁
公平锁、非公平锁(syn)
互斥锁(syn)、读写锁
可重入锁(syn)
分段锁
synchronized JDK1.6锁升级(无锁 -> 偏向锁 (非锁)-> 轻量级锁 -> 重量级锁（1.6前都是）

众所周知 synchronized 关键字是解决并发问题常用解决方案，有以下三种使用方式:

  • 同步普通方法，锁的是当前对象。

  • 同步静态方法，锁的是当前 Class 对象。

  • 同步块，锁的是 () 中的对象。

多线程特性
原子性：指一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执
行
可见性：是指多个线程访问一个资源时，该资源的状态、值信息等对于其他线程都是可见的。
有序性：指程序中代码的执行顺序 （编译器会重排）

package com.xiaohu.mybatis.main;

import java.util.concurrent.TimeUnit;

/**
 * @author 小胡哥哥
 * NO BB show your code
 */
public class SynchronizedTest {
    public static void main(String[] args) {
        SynchronizedTest test = new SynchronizedTest();
        //synchronized修饰实例方法
        new Thread(() -> test.testSync()).start();
        new Thread(() -> test.testSync()).start();

        //synchronized修饰静态方法
        /*new Thread(() -> SynchronizedTest.testSyncForStatic()).start();
        new Thread(() -> SynchronizedTest.testSyncForStatic()).start();*/

        //正常方法
        //new Thread(() -> test.test()).start();
        //new Thread(() -> test.test()).start();
    }

    //加锁方法
    public synchronized void testSync() {
        System.out.println("进入testSync方法>>>>>>>>>>>>>>>>>>>>>");
        try {
            //模拟方法体尚未执行完毕
            TimeUnit.HOURS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //加锁方法
    public synchronized static void testSyncForStatic() {
        System.out.println("进入testSYNC方法>>>>>>>>>>>>>>>>>>>>>");
        try {
//模拟方法体尚未执行完毕
            TimeUnit.HOURS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //正常方法
    public void test() {
        System.out.println("进入test方法>>>>>>>>>>>>>>>>>>>>>");
        try {
            //模拟方法体尚未执行完毕
            TimeUnit.HOURS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

通过测试，加锁的实例方法和静态方法只有一个线程进入了方法，其他的线程一直在等待，而没有加锁的方法多线程正常执行，同一时刻，只有一个线程保证了原子性
在这里插入图片描述

2.2 反汇编寻找锁实现原理

通过jdk自带的一个工具:javap,对字节码进行反编译:

public class Test {
private static Object object = new Object();
public synchronized void testMethod() {
System.out.println("Hello World -synchronized method ");
}
public static void main(String[] args) {
synchronized (object) {
System.out.println("Hello World -synchronized block ");
}
}
}

在这里插入图片描述
我们可以看到，经过被synchronized修饰的代码块，多了两个指令，一个monitorenter和一个monitorexit，也就是说jvm通过这两指令实现同步
在这里插入图片描述
我们可以看到，经过被synchronized修饰的方法，是通过ACC_SYNCHRONIZED 修饰，会隐式调用monitorenter和monitorexit这两个指令。

口说无凭，让我们继续深入源码探究:

通过查询jvm规范，我们了解到monitorenter的原理解释

https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.monitorenter
在这里插入图片描述
经过翻译得知:

monitorenter

每一个对象都会和一个监视器monitor关联。

监视器被占用时会被锁住，其他线程无法来获取该monitor。

当JVM执行某个线程的某个方法内部的monitorenter时，它会尝试去获取当前对象对应的monitor的所有权。其过程如下：

  1. 若monior的进入数为0，线程可以进入monitor，并将monitor的进入数置为1。当前线程成为

monitor的owner（所有者）

  1. 若线程已拥有monitor的所有权，允许它重入monitor，则进入monitor的进入数加1

  2. 若其他线程已经占有monitor的所有权，那么当前尝试获取monitor的所有权的线程会被阻塞，直

到monitor的进入数变为0，才能重新尝试获取monitor的所有权。

monitorexit

  1. 能执行monitorexit指令的线程一定是拥有当前对象的monitor的所有权的线程。

  2. 执行monitorexit时会将monitor的进入数减1。当monitor的进入数减为0时，当前线程退出

monitor，不再拥有monitor的所有权，此时其他被这个monitor阻塞的线程可以尝试去获取这个

monitor的所有权，monitorexit释放锁。

monitorexit插入在方法结束处和异常处，JVM保证每个monitorenter必须有对应的monitorexit。

关于monitorenter和monitorexit描述文字过多，大概流程看图说话
在这里插入图片描述

总结

通过上面的流程我们发现
1、synchronized是靠Monitor关联拿到锁的
2、如果竞争的时候拿不到锁，线程就去竞争队列
3、如果拿到锁了，第二次拿，它又拿到锁,其他线程进入阻塞队列
4、如果拿到锁的线程调用了wait方法，其他线程进入等待队列
5、释放锁，需要将计数器减减操作
6、出现异常，也释放锁。

这时又有问题，线程拿到锁干了什么？没拿到线程又在干什么？？

通过查阅HotSpot之Monitor竞争源码可知

//锁竞争InterpreterRuntime::monitorenter
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread,
BasicObjectLock* elem))
#ifdef ASSERT
thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
if (PrintBiasedLockingStatistics) {
Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
}
Handle h_obj(thread, elem->obj());
assert(Universe::heap()->is_in_reserved_or_null(h_obj()),
"must be NULL or an object");
if (UseBiasedLocking) {
// Retry fast entry if bias is revoked to avoid unnecessary inflation
ObjectSynchronizer::fast_enter(h_obj, elem->lock(), true, CHECK);
} else {
// 重量级锁，最终调用了objectMonitor.cpp中的ObjectMonitor::enter
ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);

通过这，我们了解到多线程进入InterpreterRuntime::monitorenter方法时，会进行锁竞争，没拿到锁的线程会进入竞争队列

//重量级锁入口
void ATTR ObjectMonitor::enter(TRAPS) {
Thread * const Self = THREAD ;
void * cur ;
// 1、通过CAS（原子操作）操作尝试把monitor的_owner字段设置为当前线程(开始竞争)
cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL) ;
if (cur == NULL) {
// Either ASSERT _recursions == 0 or explicitly set _recursions = 0.
assert (_recursions == 0 , "invariant") ;
assert (_owner == Self, "invariant") ;
// CONSIDER: set or assert OwnerIsThread == 1
return ;
}
// 2、拿到锁；计数+1，recursions++
if (cur == Self) {
_recursions ++ ;//第一次进入(计数+1)
return ;
}
if (Self->is_lock_owned ((address)cur)) {
assert (_recursions == 0, "internal state error");
_recursions = 1 ;
_owner = Self ;
OwnerIsThread = 1 ;
return ;
}
assert(Self->_Stalled == 0, "invariant") ;
Self->_Stalled = intptr_t(this) ;
if (Knob_SpinEarly && TrySpin (Self) > 0) {
assert (_owner == Self , "invariant") ;
assert (_recursions == 0 , "invariant") ;
assert (((oop)(object()))->mark() == markOopDesc::encode(this),
"invariant") ;
Self->_Stalled = 0 ;
return ;
}
assert (_owner != Self , "invariant") ;
assert (_succ != Self , "invariant") ;
assert (Self->is_Java_thread() , "invariant")
 ........................

总结:

拿到锁资源的线程干了以下这些事

  1. 通过CAS尝试把monitor的owner字段设置为当前线程。

  2. 记录当前线程的进入次数，当调用wait释放锁资源的时候，该线程可以再次申请拿锁，所以synchronized优化后，也是个可重入锁，执行recursions ++ ，记录重入的次数。

  3. 而获取锁失败的线程进入竞争队列进行等待

HotSpot源码之Monitor等待

//拿不到锁的线程他们都去干什么了？？
void ATTR ObjectMonitor::EnterI (TRAPS) {
Thread * Self = THREAD ;
assert (Self->is_Java_thread(), "invariant") ;
assert (((JavaThread *) Self)->thread_state() == _thread_blocked ,
"invariant") ;
// 没拿到锁，还是要尝试TryLock一次
if (TryLock (Self) > 0) {
//拿到锁执行，在返回
assert (_succ != Self , "invariant") ;
assert (_owner == Self , "invariant") ;
assert (_Responsible != Self , "invariant") ;
return ;//成功获取
}
DeferredInitialize () ;
//没拿到锁，开始TrySpin自旋（CAS,while循环）
if (TrySpin (Self) > 0) {
assert (_owner == Self , "invariant") ;
assert (_succ != Self , "invariant") ;
assert (_Responsible != Self , "invariant") ;
return ;
}
.....................

总结:

  1. 竞争失败的线程会封装为一个成ObjectWaiter对象node，状态设置成ObjectWaiter::TS_CXQ（竞争队列)

  2. 在for循环中，通过CAS进入竞争队列中

  3. 结点进入竞争队列会一直不断自旋拿锁，在并发环境下，持有锁线程的资源有可能会释放锁资源，如果仍然没拿到锁，就会死心，进行park休眠

  4. 当线程唤醒后，会从挂起的点进行ObjectMonitor::TryLock尝试获取锁

HotSpot之Monitor锁释放

1.调用ObjectMonitor::exit，将recursions减减操作，知道为0

2.为0后，唤醒竞争队列的线程

3.唤醒线程后，继续争夺锁，重复之前的步骤（锁竞争-----等待----释放

飞奔的小胡
关注
Java 同步锁(synchronized)详解及实例
08-30
Java中的同步锁，即`synchronized`关键字，是Java多线程编程中用于解决并发问题的重要机制。它确保了对共享资源的互斥访问，防止数据的不一致性。当我们有多线程环境并涉及到共享数据时，可能会出现竞态条件，就像...
理解Monitor监视器锁原理
qq_43783527的博客
03-11 6171
理解Monitor监视器锁原理 任何一个对象都有一个Monitor与之关联，当且一个Monitor被持有后，它将处于锁定状态。Synchronized在JVM里的实现都是 基于进入和退出Monitor对象来实现方法同步和代码块同步，虽然具体实现细节不一样，但是都可以通过成对的MonitorEnter和MonitorExit指令来实现。 • monitorenter：每个对象都是一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monito
jvm指令monitorenter，monitorexit与synchronization关键字
nobody
02-26 7305
monitorenter与monitorexit指令主要和java并发关键字synchronization 在jvm层指令的实现有关系。 synchronization 方法的实现并没有采用这两个指令。 monitorenter主要是获取监视器锁，monitorexit主要是释放监视器锁。 monitorenter Operation Enter monitor for objec...
java多线程并发(一)
weixin_38319425的博客
02-28 550
java并发编程知识点
Monitor.Enter() 和 Monitor.Exit()
bemodesty的博客
03-30 1346
Monitor 方法是静态的，不需要生成Monitor 类的实例就可以直接调用它们。在.NET Framework 中，每个对象都有一个与之关联的锁，对象可以得到并释放它以便于在任意时间只有一个线程可以访问对象实例变量和方法。类似的，.NET Framework 中的每个对象都提供一个允许自己进入等待状态的机制。与锁的机制类似，这种机制的主要目的是为了实现线程间通信。当一个线程进入到一个对象的关键部分且需要一个特定条件并假设另外一个线程将会在同样的关键区域中创建条件时这种机制才会发生。 现在比较特别的.
redis-springboot、分布式锁
weixin_48112109的博客
08-03 380
redis实现分布式锁，整合springboot
Java 多线程同步 锁机制与synchronized深入解析
09-05
锁机制是Java实现同步的主要手段，其中synchronized关键字扮演了核心角色。 synchronized可以用于修饰方法或代码块，两者在锁的粒度上有区别。同步方法的锁粒度较大，整个方法体被视为同步区域，而同步代码块则更细...
支持10000同步锁，Spring Boot，Java
02-23
在Java编程语言中，同步锁（Synchronized）是多线程环境下确保数据一致性的重要机制。在Spring Boot框架中，我们同样可以有效地利用同步锁来处理并发问题。标题和描述提到的"支持10000同步锁"可能是指在特定场景下，...
详细解读java同步之synchronized解析
08-26
如上所述，`synchronized`是可重入的，这意味着一个线程可以多次进入持有锁的同步代码块，只要每次的进入都是对同一个对象进行同步。 ### 4. 是否是公平锁？ `synchronized`默认是非公平锁，不保证线程获取锁的...
Spring注解和同步锁不能同步问题解决
08-25
在Java中，我们可以使用synchronized关键字或Lock接口来实现同步锁。同步锁可以帮助我们解决多线程之间的数据竞争问题，从而保证数据的一致性。 三、问题解决 在使用Spring注解和同步锁时，我们可能会遇到一些问题...
Synchronized同步锁
qq_49194786的博客
09-08 1817
有关synchronized同步锁的介绍！
oracle锁
wobushixiaobailian的博客
08-12 318
文章目录oracle锁总结参考文献 以前，也晓得数据库中有锁这个东西。因为在学校里面也没遇到过。可是，进入公司之后，在培训过程中经常遇到。常常在很多人同时操作一张表时发生（以前都是自己一个人操作数据库，难怪遇不到锁
Monitor
l1394049664的博客
08-16 3980
什么是Monitor？我们可以把它理解为一个同步工具，也可以描述为一种同步机制，它通常被描述为一个对象。 与一切皆对象一样，所有的Java对象是天生的Monitor，每一个Java对象都有成为Monitor的潜质，因为在Java的设计中 ，每一个Java对象自打娘胎里出来就带了一把看不见的锁，它叫做内部锁或者Monitor锁。 Monitor 是线程私有的数据结构，每一个线程都有一个可用monit...
为Mybatis-Plus配置乐观锁使得数据同步
QWDWQWQ的博客
04-18 905
前言: 有一件商品原价80，成本70，售价100卖出，老板觉得利润低便让马硕森加价50到150卖出，但后又觉得价格太高销量不好于是又让大司降价30到120卖出。 此时若不对数据加上乐观锁和悲观锁，当马硕森和大司同时操作商品价格时，马硕森读取价格100，加价到150,完成修改。而大司也读取数据100，减价30到70，此时大司的操作覆盖了马硕森的操作。商品便以70卖出1000件瞬间,老板亏损1w，亏的都坐公交了。 解决办法 我们此时在数据库字段中加上Version版本字段 并在实体类product的Vers
同步锁（synchronized）的作用
程序猿老白~的博客
04-24 748
同步锁（synchronized）的作用1. 线程互斥:同一时刻只允许一个线程执行同步方法或同步代码块。 2. 避免线程干扰:一个线程正在操作对象,其他线程无法同时更改对象状态,保证数据的一致性。 3. 实现线程通信和等待:通过使用wait()、notify()实现等待/通知机制。
同步锁 syncharonized 和 Lock——学习笔记
qq_40875544的博客
06-09 386
同步锁 synchronized 可以锁对象，锁住的一定是公用的对象，可共用的资源，this指代当前对象可以锁。锁同一个对象时，该对象就会被加上同步锁，被加上同步锁的对象，在synchronized代码块没有执行结束之前，其他的线程，哪怕自己的类创建的其他线程，都不能再对加了锁的代码块有任何的访问。 可以锁类型 锁类型 ， 范围大 ，不特指哪一个， 其实锁的就是类加载器，锁类型的过程就...
mybatis 乐观锁实现，解决并发问题。
热门推荐
zhouzhiwengang的专栏
02-10 4万+
情景展示： 银行两操作员同时操作同一账户就是典型的例子。 比如A、B操作员同时读取一余额为1000元的账户，A操作员为该账户增加100元，B操作员同时为该账户扣除50元，A先提交，B后提交。最后实际账户余额为1000-50=950元，但本该为1000+100-50=1050。这就是典型的并发问题。 乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本(Version)记录机制
Oracle 锁详解（lock）
鱼丸丶粗面
09-10 7712
文章目录1 概述2 锁详解2.1 锁类型2.2 锁模式2.3 查询3 扩展3.1 select ... for update 进阶3.2 死锁 1 概述 #mermaid-svg-6NEx7U5yXMLtXnN3 {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-6NEx7U5yXMLtXnN3 .error-icon{fill:#552222;}#mermaid-svg-6
monitorenter、monitorexit与synchronized
ZERO
07-04 560
monitorenter Operation Enter monitor for object Description The objectref must be of type reference. Each object is associated with a monitor. A monitor is locked if and only if it has an owner. The thread that executes monitorenter attempts to gain owners
java同步锁synchronized使用案例
最新发布
08-30
Java中的synchronized关键字是一种用于实现同步的机制。它可以应用于方法和代码块，以确保在同一时刻只有一个线程可以访问共享资源。 以下是一些使用synchronized关键字的案例： 1. 多线程访问共享资源：考虑一个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值