现在不太清楚,

    public static void main(String[] args) {

        Object object=new Object();
System.out.println("before synchronized start");
synchronized (object) {
int am =object.hashCode();
System.out.println("start");
synchronized (object) {
int a=object.hashCode();
System.out.println("inner"); }
System.out.println("end"); }

断点

//%note monitor_1
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 {
ObjectSynchronizer::slow_enter(h_obj, elem->lock(), CHECK);
}
assert(Universe::heap()->is_in_reserved_or_null(elem->obj()),
"must be NULL or an object");
#ifdef ASSERT
thread->last_frame().interpreter_frame_verify_monitor(elem);
#endif
IRT_END

这个只会在嵌套的第二个里面,搞不懂,为什么第一次不会再第一次synchronized进入

通过thread打印栈帧

(gdb) x/50xg 0x7f8c1cd976d0
0x7f8c1cd976d0: 0xffffffffdb26d002 BasicObjectLock
0x00000000f3886948
0x7f8c1cd976e0: 0x0000000000000001
0x00000000f3886948 obj
0x7f8c1cd976f0: 0x00007f8c1cd976d0 -8
0x00007f8c192357be -7
0x7f8c1cd97700: 0x00007f8c1cd97798 -6
0x00007f8c19235aa8 -5
0x7f8c1cd97710: 0x0000000000000000 -4
0x00007f8c192359c8 -3
0x7f8c1cd97720: 0x0000000000000000 -2
0x00007f8c1cd97798 -1
0x7f8c1cd97730: 0x00007f8c1cd97800 fp()
0x00007f8c05000671
0x7f8c1cd97740: 0x0000000000000000
0x0000000000000000
0x7f8c1cd97750: 0x0000000000000000
0x0000000000000000
0x7f8c1cd97760: 0x0000000000000000
0x0000000000000000
0x7f8c1cd97770: 0x0000000000000000
0x00000000f3886948
0x7f8c1cd97780: 0x0000000033909752
0x00000000f3886948 0bj
0x7f8c1cd97790: 0x00000000f3886948 obj
0x00000000f3886938 args[]
0x7f8c1cd977a0: 0x00007f8c00001fa0 -12
0x00007f8c1cd98700 -11
0x7f8c1cd977b0: 0x0000000000000000 -10
0x00007f8c1cd97b40 -9
0x7f8c1cd977c0: 0x0000000000000001 -8
0x00007f8c05000564 -7
0x7f8c1cd977d0: 0x00007f8c1cd97880 -6
0x00007f8c1cd97d28 -5
0x7f8c1cd977e0: 0x00007f8c0000000a -4
0x00007f8c192359c8 -3
0x7f8c1cd977f0: 0x00007f8c0501e2e0 -2
0x00007f8c1cd97b40 -1
0x7f8c1cd97800: 0x00007f8c1cd97a40 saved rbp
0x00007f8c1b486e2e return addr
0x7f8c1cd97810: 0x0000000000000001 param size
0x00007f8c1400b800 thread
0x7f8c1cd97820: 0x00007f8c1400b800
0x00007f8c1cd97b30
0x7f8c1cd97830: 0x00007f8c1cd97c50 0x00007f8c1cd97d20
0x7f8c1cd97840: 0x00007f8c1400b800 0x00007f8c1400c078
0x7f8c1cd97850: 0x00007f8c1400c0e8 0x00007f8c1400c108

sp头顶是是elem

(gdb) p * elem
$1 = {_lock = {_displaced_header = 0xffffffffdbae1002}, _obj = 0xf3886978}

那么看下BasicObjectLock定义

class BasicObjectLock VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
private:
BasicLock _lock; // the lock, must be double word aligned
oop _obj; // object holds the lock; public:
// Manipulation
....
};
(gdb) p elem._lock
$3 = {_displaced_header = 0xffffffffdbae1002}

那看下lock定义

class BasicLock VALUE_OBJ_CLASS_SPEC {
friend class VMStructs;
private:
volatile markOop _displaced_header;
public:
markOop displaced_header() const { return _displaced_header; }
void set_displaced_header(markOop header) { _displaced_header = header; } void print_on(outputStream* st) const; // move a basic lock (used during deoptimization
void move_to(oop obj, BasicLock* dest); static int displaced_header_offset_in_bytes() { return offset_of(BasicLock, _displaced_header); }
};

就是记录的一个markOop头

  enum { locked_value             = 0, //轻量级
unlocked_value = 1, //无锁
monitor_value = 2, 重量级
marked_value = 3,
biased_lock_pattern = 5 偏向锁
};

那么打印一下这个oop中指示的互斥锁对象

(gdb) p * inf
$43 = {
static SpinCallbackFunction = 0x0,
static SpinCallbackArgument = 0,
_header = 0x3390975201,
_object = 0xf3886978,
SharingPad = {-7.4786357953083842e+240},
_owner = 0x7f24b05236e0,
_previous_owner_tid = 0,
_recursions = 0,
OwnerIsThread = 0,
_cxq = 0x0,
_EntryList = 0x0,
_succ = 0x0,
_Responsible = 0x0,
_PromptDrain = -235802127,
_Spinner = -235802127,
_SpinFreq = 0,
_SpinClock = 0,
_SpinDuration = 5000,
_SpinState = -1012762419733073423,
_count = 0,
_waiters = 0,
_WaitSet = 0x0,
_WaitSetLock = 0,
_QMix = -235802127,
FreeNext = 0x0,
StatA = -1012762419733073423,
StatsB = -1012762419733073423,
static _sync_ContendedLockAttempts = 0x7f24a800d8f8,
static _sync_FutileWakeups = 0x7f24a800d9c8,
static _sync_Parks = 0x7f24a800da88,
static _sync_EmptyNotifications = 0x7f24a800db48,
static _sync_Notifications = 0x7f24a800dc08,
static _sync_SlowEnter = 0x7f24a800dcc8,
static _sync_SlowExit = 0x7f24a800dd88,
static _sync_SlowNotify = 0x7f24a800de48,
static _sync_SlowNotifyAll = 0x7f24a800df08,
static _sync_FailedSpins = 0x0,
static _sync_SuccessfulSpins = 0x7f24a800e088,
static _sync_PrivateA = 0x7f24a800e148,
static _sync_PrivateB = 0x7f24a800e208,
static _sync_MonInCirculation = 0x7f24a800e2c8,
static _sync_MonScavenged = 0x7f24a800e388,
static _sync_Inflations = 0x7f24a800d378,
static _sync_Deflations = 0x7f24a800d838,
static _sync_MonExtant = 0x7f24a800e448,
static Knob_Verbose = 0,
static Knob_SpinLimit = 5000
}
(gdb) p object
$44 = (oopDesc *) 0xf3886978

jvm源码解读--16 锁_开头的更多相关文章

  1. jvm源码解读--16 cas 用法解析

    CAS的意思是campare and sweep比较交换 这个如果不用代码会比较抽象,那么在源码中进行解释 void ATTR ObjectMonitor::enter(TRAPS) { // The ...

  2. JVM 源码解读之 CMS 何时会进行 Full GC

    t点击上方"涤生的博客",关注我 转载请注明原创出处,谢谢!如果读完觉得有收获的话,欢迎点赞加关注. 前言 本文内容是基于 JDK 8 在文章 JVM 源码解读之 CMS GC 触 ...

  3. synchronized的jvm源码分析聊锁的意义

    上篇写完了ReentrantLock源码实现,从我们的角度分析设计锁,在对比大神的实现,顺道拍了一波道哥的马屁,虽然他看不到,哈哈.这一篇我们来聊一聊synchronized的源码实现,并对比reen ...

  4. jvm源码解读--17 Java的wait()、notify()学习

    write and debug by 张艳涛 wait()和notify()的通常用法 A线程取得锁,执行wait(),释放锁; B线程取得锁,完成业务后执行notify(),再释放锁; B线程释放锁 ...

  5. jvm源码解读--11 ldc指令的解读

    写一个java文件 public static void main(String[] args) { String str1="abc"; String str2 ="a ...

  6. jvm源码解读--08 创建oop对象,将static静态变量放置在oop的96 offset处

    之前分析的已经加载的.Class文件中都没有Static 静态变量,所以也就没这部分的解析,自己也是不懂hotspot 将静态变量放哪里去了,追踪源码之后,看清楚了整个套路,总体上来说,可以举例来说对 ...

  7. Redisson源码解读-分布式锁

    前言 Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid).Redisson有一样功能是可重入的分布式锁.本文来讨论一下这个功能的特点以及源 ...

  8. jvm源码解读--13 gc_root中的栈中oop的mark 和copy 过程分析

    粘贴源码 package com.test; import java.util.Random; public class Test { static int number=12; private in ...

  9. Redisson源码解读-公平锁

    前言 我在上一篇文章聊了Redisson的可重入锁,这次继续来聊聊Redisson的公平锁.下面是官方原话: 它保证了当多个Redisson客户端线程同时请求加锁时,优先分配给先发出请求的线程.所有请 ...

随机推荐

  1. 【VBA】测试程序运行时间,延时方法

    测试程序运行时间 Dim start As Date start = Now() Dim i As Long For i = 0 To 10000000 ' 10 million Next Debug ...

  2. 【VBA】打开关闭工作簿等

    打开关闭工作簿等 1 Sub 打开工作簿() 2 Dim sFilePath As String 3 sFilePath = "D:\A.xls" 4 Dim oWB As Wor ...

  3. Pipeline模式与Factory+Provider模式的应用

    前言 我正在写FastGithub这个小麻雀项目,里面主要涉及了Pipeline模式和Factory+Provider模式,这两种设计模式,让这个项目在"ip扫描"和"i ...

  4. Linux命令基础(二)

    一.列表显示目录内容-ls 1.显示目录中内容,包括子目录和文件相关属性信息 ls(列表的形式去显示目录内容)                    [选项](可有可无的)              ...

  5. 简单聊聊Ehcache缓存

    最近工作没有那么忙,有时间来写写东西.今年的系统分析师报名已经开始了,面对历年的真题,真的难以入笔,所以突然对未来充满了担忧,还是得抓紧时间学习技术. 同事推了一篇软文,看到了这个Ehcache,感觉 ...

  6. theUnforgiven——项目冲刺

    这个作业属于哪个课程 https://edu.cnblogs.com/campus/zswxy/computer-science-class1-2018/ 小组号和队名 8组theUnforgiven ...

  7. 跟着官方文档学Maven构建生命周期

    在IntelliJ IDEA中,显示了Maven的Lifecycle: 只需要学习这些命令,就能构建一个Maven项目. 三个内置生命周期 Maven内置了三个生命周期:clean.default和s ...

  8. vue调用子组件方法时,参数传不过去

    有可能是因为子组件方法用了 async  await 子组件去掉async就好了

  9. Https:SSL双向认证机制(理论知识)

    1.基础知识 这部分内容主要解释一些概念和术语,最好是先理解这部分内容. 1.1.公钥密码体制(public-key cryptography) 公钥密码体制分为三个部分,公钥.私钥.加密解密算法,它 ...

  10. 6-x2 echo命令:将指定字符串输出到 STDOUT

    echo 用法 常用转义符 echo 用法     echo 用来在终端输出字符串,并在最后默认加上换行符. echo 加上-n参数可以使数据字符串后不再换行 echo 加上-e参数可以解析转义字符 ...