现在不太清楚,

    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. 学习响应式编程 Reactor (2) - 初识 reactor

    Reactor Reactor 是用于 Java 的异步非阻塞响应式编程框架,同时具备背压控制的能力.它与 Java 8 函数式 Api 直接集成,比如 分为CompletableFuture.Str ...

  2. 有效Ajax案例

    <script>$(document).ready(function(){ $("input:submit").click(function(){ $.ajax({ t ...

  3. 【dp】10-8题解 vacation

    vacations 原题codeforeces round 363 (Div2) c 题目描述 暑假到了, Pb 正在计划他的假期. Pb 准备假期去体育馆锻炼或看电影.但体育馆和电影院都有可能当天不 ...

  4. .NET解密得到UnionID

    由于微信没有提供.NET的解码示例代码,自己搜索写了一个,下面的代码是可用的 var decryptBytes = Convert.FromBase64String(encrypdata); var ...

  5. Windows10上基于Visual Studio Code安装Golang开发环境

    GoLang简介 Go编程语言是一个开源项目,它使程序员更具生产力. Go语言具有很强的表达能力,它简洁.清晰而高效.得益于其并发机制,用它编写的程序能够非常有效地利用多核与联网的计算机,其新颖的类型 ...

  6. 17、linux root用户密码找回

    17.1.救援模式: 光盘模式启动(第一启动项) 删除/mnt/sysimage/etc/passwd root的密码,halt重启. 改为硬盘启动模式,无密码进入root,为root新建密码 17. ...

  7. 46、django工程(view)

    46.1.django view 视图函数说明: 1.http请求中产生两个核心对象: (1)http请求:HttpRequest对象. (2)http响应:HttpResponse对象. 2.vie ...

  8. Pandas高级教程之:plot画图详解

    目录 简介 基础画图 其他图像 bar stacked bar barh Histograms box Area Scatter Hexagonal bin Pie 在画图中处理NaN数据 其他作图工 ...

  9. POJ 1681 高斯消元 枚举自由变元

    题目和poj1222差不多,但是解法有一定区别,1222只要求出任意一解,而本题需要求出最少翻转次数.所以需要枚举自由变元,变元数量为n,则枚举的次数为1<<n次 #include < ...

  10. Redis 底层数据结构之字典

    文章参考 <Redis 设计与实现>黄建宏 字典 在字典中,每个键都是独一无二的,程序可以在字典中根据键查找与之相关联的值,或者通过键来更新和删除值. 字典在 Redis 中的应用相当广泛 ...