三种使用场景，示例代码；
public class SynchronizePrincipe {
public synchronized static void fun1(){}
public synchronized void fun2(){}
public void fun3() {
synchronized (this){}
}
}
通过javap -c -v命令反编译后（部分代码）；
public static synchronized void fun1();
descriptor: ()V
// 看这里
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
public synchronized void fun2();
descriptor: ()V
// 看这里
flags: ACC_PUBLIC, ACC_SYNCHRONIZED
public void fun3();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: aload_0
1: dup
2: astore_1
// 看这里
3: monitorenter
4: aload_1
// 看这里
5: monitorexit
6: goto 14
9: astore_2
10: aload_1
// 看这里
11: monitorexit
ACC_SYNCHRONIZED标识，会隐式调用到下面两个方法；monitorenter，两个monitorexit，避免异常未释放锁；总结：sychronized本质就是对monitor的争夺，在持有重量级锁的对象头中，存储了monitor的指针。
Java对象由三个部分组成；
JDK 1.6 增加的锁优化流程，之前只有重量级锁。
-XX:+UseBiasedLocking 启用偏向锁，默认启用
-XX:+PrintFlagsFinal 打印JVM所有参数
-XX:BiasedLockingStartupDelay=4000 偏向锁启用延迟时间，默认4秒
-XX:BiasedLockingBulkRebiasThreshold=20 批量重偏向阈值，默认20
-XX:BiasedLockingBulkRevokeThreshold=40 批量撤销阈值，默认40
-XX:BiasedLockingDecayTime=25000
<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.16</version>
</dependency>
统一打印对象头方法；
public static void print(Object flag, Object object) {
String str = ClassLayout.parseInstance(object).toPrintable();
System.out.println(flag + ".......................................");
System.out.println(str);
}
public static void main(String[] args) {
Object init = new Object();
// non-biasable 不可偏向
print("init before", init);
synchronized (init) {
// thin lock 轻量级锁
print("init sync", init);
}
sleep(4000);
Object object = new Object();
// biasable 可偏向模式，默认4S后开启偏向模式
print("object before", object);
synchronized (object) {
// biased 持有偏向锁
print("object sync", object);
}
// biased 偏向锁不会被释放
print("object after", object);
Thread t1 = new Thread(() -> {
synchronized (object) {
// thin lock 持有轻量级锁，不同线程请求
print("[t1]object sync", object);
}
// non-biasable 不可偏向模式
print("[t1]object after", object);
});
t1.start();
sleep(100);
Thread t2 = new Thread(() -> {
synchronized (object) {
// thin lock 持有轻量级锁，不同线程请求
print("[t2]object sync", object);
sleep(1000);
// fat lock 重量级锁，下面加锁失败导致
print("[t2]object sync sleep", object);
}
});
t2.start();
sleep(500);
synchronized (object) {
// fat lock 重量级锁
print("[main]object sync", object);
}
// fat lock 重量级锁不会撤销，线程结束变为不可偏向模式
print("[main]object after", object);
}
public static void main(String[] args) throws InterruptedException {
print("oldPrincipe", new SynchronizedPrincipe());
int loop = 39;
List<SynchronizedPrincipe> list = new ArrayList<>();
for (int i = 0; i < loop; i++) {
SynchronizedPrincipe principe = new SynchronizedPrincipe();
list.add(principe);
}
for (int thread = 1; thread <= 3; thread++) {
Thread t1 = new Thread(() -> {
for (int i = 0; i < list.size(); i++) {
print(i + 1, list.get(i));
synchronized (list.get(i)) {
// 19: thin lock
// 20: biased (Rebias)
print(i + 1, list.get(i));
}
print(i + 1, list.get(i));
}
});
t1.start();
sleep(1000);
}
SynchronizedPrincipe newPrincipe = new SynchronizedPrincipe();
// non-biasable (Revoke)
print("newPrincipe", newPrincipe);
}