一：轻量锁和偏向锁的区别：

（1）争夺轻量锁失败时，自旋尝试抢占锁
（2）轻量级锁每次退出同步块都需要释放锁，而偏向锁是在竞争发生时才释放锁，线程不会主动释放偏向锁

二：为什么每个对象都能作为一个锁？

java对象 是天生的Monitor，每一个对象都有成为Monitor的潜质，因为在Java设计中，每一个Java对象自打娘胎里出来就带一个看不见的锁，它叫内部锁或者Monitor锁

三：Monitror与java对象以及线程如何关联？

四:锁升级后，hashcode去哪儿了?

五：什么是锁消除？

/**/*** @Author：xiaoqi* @creat 2023/8/12 11:27* 锁消除* 从JIT角度看想相当于无视他，synchronized(o)不存在了* 这个锁对象并没有被共用扩散到其他线程使用* 极端的说就是根本没有加锁对象的底层机器码，消除了锁的使用*/
public class LockClearUpDemo {static Object object = new Object();public void m1() {//锁消除问题，JIT会无视它，synchronized(o)每次new出来的，都不存在了，非正常的Object o = new Object();synchronized (o) {System.out.println("-----------hello LockClearUpDemo" + "\t" + o.hashCode() + "\t" + object.hashCode());}}public static void main(String[] args) {LockClearUpDemo lockClearUpDemo = new LockClearUpDemo();for (int i = 0; i < 10; i++) {new Thread(() -> {lockClearUpDemo.m1();}, String.valueOf(i)).start();}}
}
/*** -----------hello LockClearUpDemo	229465744	57319765* -----------hello LockClearUpDemo	219013680	57319765* -----------hello LockClearUpDemo	1109337020	57319765* -----------hello LockClearUpDemo	94808467	57319765* -----------hello LockClearUpDemo	973369600	57319765* -----------hello LockClearUpDemo	64667370	57319765* -----------hello LockClearUpDemo	1201983305	57319765* -----------hello LockClearUpDemo	573110659	57319765* -----------hello LockClearUpDemo	1863380256	57319765* -----------hello LockClearUpDemo	1119787251	57319765*/

六：什么是锁粗化？

/*** @Author：xiaoqi* @creat 2023/8/12 12:27* 锁粗化* 假如方法中首尾相接，前后相邻的都是同一个锁对象，那JIT编译器会把这几个synchronized块合并为一个大块* 加粗加大范围，一次申请锁使用即可，避免次次的申请和释放锁，提高了性能*/
public class LockBigDemo {static Object objectLock = new Object();public static void main(String[] args) {new Thread(() -> {synchronized (objectLock) {System.out.println("111111111111");}synchronized (objectLock) {System.out.println("222222222222");}synchronized (objectLock) {System.out.println("333333333333");}synchronized (objectLock) {System.out.println("444444444444");}//底层JIT的锁粗化优化synchronized (objectLock) {System.out.println("111111111111");System.out.println("222222222222");System.out.println("333333333333");System.out.println("444444444444");}}, "t1").start();}
}

七：synchronized是怎么实现的?

1. 同步方法的常量池中会有一ACC_SYNCHRONIZED 标志。当某个线程要访问某个方法的时候，会检查是否有 ACC_SYNCHRONIZED），如果有设置，则需要先获得监视器锁，然后开始执行方法，方法执行之后再释放监视器锁。这时如果其他线程来请求执行方法，会因为无法获得监视器锁而被阻断住。值得注意的是，如果在方法执行过程中,发生了异常，并且方法内部并没有处理该异常，那么在异常被抛到方法外面之前监视器锁会被自动释放。
2. 同步代码块使用(monitorenter和 monitorexit 两个指令实现。可以把执行（monitorent
   er指令理解为加锁，执行（monitorexit」理解为释放锁。每个对象维护着一个记录着被锁次
   数的计数器。未被锁定的对象的该计数器为 0，当一个线程获得锁（执行（monitorenter））
   后，该计数器自增变为 1 ，当同一个线程再次获得该对象的锁的时候，计数器再次自增。当同一个线程释放锁（执行（monitorexit）指令）的时候，计数器再自减。当计数器为 0 的时候。锁将被释放，其他线程便可以获得锁。

八：synchronized锁的是什么？

同步方法：public synchronized void print(){}
public static synchronized void print(){}
同步代码块：synchronized (this){}
synchronized (Xxx.class){}
总结一下：

1. synchronized的普通方法，其实锁的是调用这个方法的实例对象，而synchronized的静态方法，其实锁的是这个方法属于的类对象。
2. synchronized(this)，其实锁的是this这个实例对象，而synchronized(Xxx.Class)，其实锁的是这个类对象。
   一个类只有一个类对象，但是有很多个实例对象。

九：synchronized是如何保证原子性、可见性、有序性的？

1. synchronized如何保证的原子性呢？
   synchonized其实是通过 monitorenter 和 monitorexit 这两个字节码指令实现的。当线程执行到 monitorenter 的时候要先获得锁，才能执行后面的方法。当线程执行到monitorexit 的时候则要释放锁,在未释放之前，其他线程是无法再次获得锁的，所以，通过monitorenter和monitorexit指令，可以保证被synchronized修饰的代码在同一时间只能被一个线程访问，在锁末释放之前，无法被其他线程访问到。
2. synchronized如何保证有序性？
   由于synchronized修饰的代码，同一时间只能被同一线程访问。那么也就是单线程执行的。所以，可以保证其有序性。
3. synchronized如何保证可见性？