synchronized底层的锁

最新推荐文章于 2025-04-08 10:16:24 发布

' '

最新推荐文章于 2025-04-08 10:16:24 发布

阅读量264

点赞数 4

文章标签： java jvm 开发语言

本文链接：https://blog.youkuaiyun.com/weixin_56267337/article/details/126569239

版权

本文详细介绍了Java中的锁机制，包括偏向锁、无锁、轻量级锁和重量级锁的概念及工作原理。通过实例演示了不同锁状态下对象的变化，并解释了如何通过代码观察这些状态。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

主要分为以下的几个锁（偏向锁无锁轻量级锁重量级锁）

偏向锁：大部分情况下，锁不仅仅不存在多线程竞争，而是总是由同一个线程多次获得，为了让线程获取锁的代价更低就引入了偏向锁。

没有开启偏向锁的情况下：

无锁：一个对象如果没有被任何线程当做锁去使用，就是无锁状态。

编辑

轻量级锁：一个对象如果被一个线程当做锁去使用，就是轻量级锁状态。

编辑

重量级锁：一个对象当做锁被一个线程持有，另外一个线程还继续去获取该锁，就是重量级锁。

开启偏向锁的情况下：

无锁可偏向

总结：

偏向锁：大部分情况下，锁不仅仅不存在多线程竞争，而是总是由同一个线程多次获得，为了让线程获取锁的代价更低就引入了偏向锁。

没有开启偏向锁的情况下：

无锁：一个对象如果没有被任何线程当做锁去使用，就是无锁状态。

public class test2 {
	public static void main(String[] args) {
		A a=new A();
		String str = ClassLayout.parseInstance(a).toPrintable();//获取锁的状态
		System.out.println(str);
		//此时是无锁的状态
	}
}
class A{
	
}

在value的下面第一行中 01代表了无锁的状态

轻量级锁：一个对象如果被一个线程当做锁去使用，就是轻量级锁状态。

public class test2 {
    public static void main(String[] args) throws InterruptedException {
		A a=new A();
		String str = ClassLayout.parseInstance(a).toPrintable();//获取锁的状态
		System.out.println(str);
		//此时是无锁的状态
		
		new Thread() {
			public void run() {
				//把a作为锁对象
				synchronized(a) {
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
			}
		}.start();
		
		Thread.sleep(10);//保证线程获取锁对象
		str = ClassLayout.parseInstance(a).toPrintable();//获取锁的状态
		System.out.println(str);//此时该锁的为轻量级锁
    }
}
class A{
	
}

此时value下的8位二进制数的后两位是 00 ，则代表是轻量级锁。

重量级锁：一个对象当做锁被一个线程持有，另外一个线程还继续去获取该锁，就是重量级锁。

public class test2 {
	public static void main(String[] args) throws InterruptedException {
		A a=new A();
		String str = ClassLayout.parseInstance(a).toPrintable();//获取锁的状态
		System.out.println(str);
		//此时是无锁的状态
		
		new Thread() {
			public void run() {
				//把a作为锁对象
				synchronized(a) {
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
			}
		}.start();
		
		Thread.sleep(10);//保证线程获取锁对象
		str = ClassLayout.parseInstance(a).toPrintable();//获取锁的状态
		System.out.println(str);//此时该锁的为轻量级锁
		
		//第二个线程
		new Thread() {
			public void run() {
				//把a作为锁对象
				synchronized(a) {
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
			}
		}.start();
		Thread.sleep(10);//保证线程获取锁对象
		str = ClassLayout.parseInstance(a).toPrintable();//获取锁的状态
		System.out.println(str);//此时该锁的为重量级锁。
		//此时有两个线程，第一个线程已经获取了锁且没有释放锁，
		//第二个线程要尝试获取该锁
	}
}
class A{
	
}

此时value下的8位二进制数的后两位是 10，则代表是重量级锁。

开启偏向锁的情况下：

需要先进行修改

修改偏向锁的延迟时间的参数：-XX:BiasedLockingStartupDelay=0

无锁可偏向

public class test3 {
	public static void main(String[] args) throws InterruptedException {
		A a=new A();
		String str = ClassLayout.parseInstance(a).toPrintable();//获取锁的状态
		System.out.println(str);
	}
}

此时value下的8位二进制数的后三位是 101，则代表是无锁可偏向锁。

轻量级锁可偏向

重级锁可偏向

public static void main(String[] args) throws InterruptedException {
		A a = new A();
		String str = ClassLayout.parseInstance(a).toPrintable();
		System.out.println(str);//101  无锁可偏向
		
		new Thread() {
			public void run() {
				synchronized(a) {
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				
				/*
				 * 	显示的让当前线程不结束
				 * 	如果结束了，下一个线程的id和刚才这个线程的id是一样的。
				 */
				try {
					Thread.sleep(100000000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}.start();
		Thread.sleep(100);
		str = ClassLayout.parseInstance(a).toPrintable();
		System.out.println(str);//101  无锁可偏向
		
		Thread.sleep(1000);//保证上一个线程已经把任务执行完毕了
		new Thread() {
			public void run() {
				synchronized(a) {
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();
		Thread.sleep(100);
		str = ClassLayout.parseInstance(a).toPrintable();
		System.out.println(str);//
		
		new Thread() {
			public void run() {
				synchronized(a) {
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();
		Thread.sleep(100);
		str = ClassLayout.parseInstance(a).toPrintable();
		System.out.println(str);//
	}
}