synchronized的底层实现原理

最新推荐文章于 2024-05-13 08:31:41 发布
最新推荐文章于 2024-05-13 08:31:41 发布
阅读量536 收藏
点赞数
分类专栏： 深入理解多线程 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39552268/article/details/121807938
版权

1.JDK1.6对synchronized做的优化:

传统的锁（也就是下文要说的重量级锁）依赖于系统的同步函数，在linux上使用mutex互斥锁，这些同步函数都涉及到用户态和内核态的切换、进程的上下文切换，成本较高。对于加了synchronized关键字但运行时并没有多线程竞争，或两个线程接近于交替执行的情况，使用传统锁机制无疑效率是会比较低的。

Java SE1.6为了减少获得锁和释放锁所带来的性能消耗，引入了“偏向锁”和“轻量级锁”，所以在Java SE1.6里锁一共有四种状态，无锁状态，偏向锁状态，轻量级锁状态和重量级锁状态，它会随着竞争情况逐渐升级。

偏向锁、轻量级锁、重量级锁适用于不同的并发场景：

  • 偏向锁：无实际竞争，且将来只有第一个申请锁的线程会使用锁。在JDK1.6中为了提高一个对象在一段很长的时间内都只被一个线程用做锁对象场景下的性能，引入了偏向锁
  • 轻量级锁：无实际竞争，多个线程交替使用锁；允许短时间的锁竞争。所以轻量级锁的引入就是为了提高多个线程交替使用锁和短时间竞争锁(通过自旋,这时不会膨胀为重量级锁)做的优化
  • 重量级锁：有实际竞争，且锁竞争时间长。

2.对于synchronized在jvm指令层面的疑惑:

问题： synchronized转成字节码后 直接使用monitorexit monitorenter表示加锁和解锁，monitor不是重量级锁的概念吗，偏向锁和轻量级锁在jvm指令中并没有看到相关体现，还是monitorexit monitorenter底层的实现自动对各种锁的选择做了优化?

在下面那片大佬的文章中找到了答案:

montorenter的解析入口在模板解释器中，其代码位于templateTable_x86_64.cpp#3667。通过调用路径：templateTable_x86_64#monitorenter->interp_masm_x86_64#lock_object进入到偏向锁入口macroAssembler_x86#biased_locking_enter

看来monitorenter就是进入到各种锁的一个入口，它的底层方法实现里就包含了各种锁的实现

3.具体原理可以参考这两篇文章

        我认为这篇文章在批量重偏向,批量撤销这一块写的有些问题，其余的地方都挺好的，重偏向看第二篇文章:

浅谈偏向锁、轻量级锁、重量级锁 - 简书为了换取性能，JVM在内置锁上做了非常多的优化，膨胀式的锁分配策略就是其一。理解偏向锁、轻量级锁、重量级锁的要解决的基本问题，几种锁的分配和膨胀过程，有助于编写并优化基于锁的...https://www.jianshu.com/p/36eedeb3f912

偏向锁加锁过程:

case 1：当该对象第一次被线程获得锁的时候，发现是匿名偏向状态，则会用CAS指令，将mark word中的thread id由0改成当前线程Id。如果成功，则代表获得了偏向锁，继续执行同步块中的代码。否则，将偏向锁撤销，升级为轻量级锁。

case 2：当被偏向的线程再次进入同步块时，发现锁对象偏向的就是当前线程，在通过一些额外的检查后（细节见后面的文章），会往当前线程的栈中添加一条Displaced Mark Word为空的Lock Record中，然后继续执行同步块的代码，因为操纵的是线程私有的栈，因此不需要用到CAS指令；由此可见偏向锁模式下，当被偏向的线程再次尝试获得锁时，仅仅进行几个简单的操作就可以了，在这种情况下，synchronized关键字带来的性能开销基本可以忽略。

case 3.当其他线程进入同步块时，发现已经有偏向的线程了，则会进入到撤销偏向锁的逻辑里，一般来说，会在safepoint中去查看偏向的线程是否还存活，如果存活且还在同步块中则将锁升级为轻量级锁，原偏向的线程继续拥有锁，当前线程则走入到锁升级的逻辑里；如果偏向的线程已经不存活或者不在同步块中，则将对象头的mark word改为无锁状态（unlocked），之后再升级为轻量级锁。

      由此可见，偏向锁升级的时机为：当锁已经发生偏向后，只要有另一个线程尝试获得偏向锁，则该偏向锁就会升级成轻量级锁。当然这个说法不绝对，因为还有批量重偏向这一机制。

这个逻辑才是对的。

        偏向锁应该没有锁记录的概念吧,下面这篇文章在偏向锁的介绍中使用了锁记录的概念,不太对吧?

https://github.com/farmerjohngit/myblog/issues/12https://github.com/farmerjohngit/myblog/issues/12

批量重偏向和批量撤销的理解:

  

       如果对象被多个线程访问，但是没有竞争，这时候偏向了线程一的对象又有机会重新偏向线程二，即可以不用升级为轻量级锁，可这和我们之前做的实验矛盾了呀，其实要实现重新偏向是要有条件的：就是超过19个对象对同一个线程如线程一撤销偏向时，那么第20个（注意从第20个开始都位偏向锁 注意连续重偏向19次后 从第20个起就会直接重偏向到线程2）及以后的对象才可以将撤销对线程一的偏向这个动作变为将第20个及以后的对象偏向线程二。如果这时候线程二批量重偏向该类的个数到达39（注意连续39个）,则当第三个线程再访问这些对象时会进行批量撤销，如果还是线程二访问这些对象，会继续批量冲偏向为线程二，而不会触发批量撤销

第二个线程连续批量冲重偏向39个线程后并且第三个线程连续撤销重偏向的锁达到39个后，从第40个起就会使得所有撤销过偏向锁的对象不再有偏向锁的状态，新创建的对象也不再有偏向锁的状态

验证代码:

package com.juc.juc;


import lombok.extern.slf4j.Slf4j;
import org.openjdk.jol.info.ClassLayout;

import java.util.ArrayList;
import java.util.List;

/**
 * @author: @zyz
 */
@Slf4j
public class ObjectHeadTest1 {
	public static void main (String[] args) throws InterruptedException {
		Thread.sleep (5000);

		List<User> list=new ArrayList<>();
		Thread thread1=new Thread (()->{
			for(int i=0;i<100;i++)
			{
				User user=new User();
				synchronized (user)
				{
//					System.out.println (("线程1: 进入synchronized"));
//					System.out.println (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
				}
				list.add(user);
			}
			try {
				Thread.sleep(10000000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		thread1.start ();
		thread1.join(3000);
		System.out.println (ClassLayout.parseInstance (list.get(18)).toPrintable ());
		System.out.println (ClassLayout.parseInstance (list.get(19)).toPrintable ());
		Thread thread2=new Thread (()->{
			for(int i=0;i<40;i++)
			{
				User user=list.get(i);
				if (i==17||i==18||i==19||i==20)
				{
					System.out.println("原T "+(i+1)+" :");
					System.out.println (ClassLayout.parseInstance (user).toPrintable ());
				}

				if (i==37||i==38||i==39||i==40||i==41||i==42)
				{
					System.out.println("原T "+(i+1)+" :");
					System.out.println (ClassLayout.parseInstance (user).toPrintable ());
				}
				synchronized (user)
				{
					if (i==17||i==18||i==19||i==20)
					{
						System.out.println("T "+(i+1)+" :");
						System.out.println (ClassLayout.parseInstance (user).toPrintable ());
					}

					if (i==37||i==38||i==39||i==40)
					{
						System.out.println("T "+(i+1)+" :");
						System.out.println (ClassLayout.parseInstance (user).toPrintable ());
					}
				}

			}
			try {
				Thread.sleep(10000000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		thread2.start ();
		thread2.join (3000);
		System.out.println("线程3：");
		Thread thread3=new Thread (()->{
			for(int i=0;i<39;i++)
			{
				User user=list.get(i);
				if (i==17||i==18||i==19||i==20)
				{
					System.out.println("原T "+(i+1)+" :");
					System.out.println (ClassLayout.parseInstance (user).toPrintable ());
				}

				if (i==37||i==38||i==39||i==40)
				{
					System.out.println("原T "+(i+1)+" :");
					System.out.println (ClassLayout.parseInstance (user).toPrintable ());
				}
				synchronized (user)
				{
					if (i==17||i==18||i==19||i==20)
					{
						System.out.println("T "+(i+1)+" :");
						System.out.println (ClassLayout.parseInstance (user).toPrintable ());
					}

					if (i==37||i==38||i==39||i==40)
					{
						System.out.println("T "+(i+1)+" :");
						System.out.println (ClassLayout.parseInstance (user).toPrintable ());
					}
				}

			}
			try {
				Thread.sleep(10000000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});
		thread3.start ();
		thread3.join(3000);
		User user=new User();
		System.out.println (ClassLayout.parseInstance (user).toPrintable ());
		System.out.println (ClassLayout.parseInstance (list.get(2)).toPrintable ());
		System.out.println (ClassLayout.parseInstance (list.get(27)).toPrintable ());
		System.out.println (ClassLayout.parseInstance (list.get(38)).toPrintable ());
		System.out.println (ClassLayout.parseInstance (list.get(42)).toPrintable ());
		System.out.println (ClassLayout.parseInstance (list.get(60)).toPrintable ());
//		synchronized (list.get(27))
//		{
//			System.out.println (ClassLayout.parseInstance (list.get(27)).toPrintable ());
//		}


	}
}

4.三种锁情况下的对象头分析验证:

1> 使用JOL工具类，打印对象头

使用maven的方式，添加jol依赖

<dependency>
  <groupId>org.openjdk.jol</groupId>
  <artifactId>jol-core</artifactId>
  <version>0.8</version>
</dependency>

2>对象头结构

64位HotSpot虚拟机Mark Word的具体含义，以供参考。需要注意的是在下图的Mark Word中，左侧为高字节，右侧为低字节

​

 来自：JOL：分析Java对象的内存布局 - 知乎通过OpenJDK官方提供的JOL(Java Object Layout)工具，我们即可很方便分析、了解一个Java对象在内存当中的具体布局情况。这里将在64位的HotSpot Java虚拟机环境下进行分析、测试 Java 对象的内存布局Java的实例对象…https://zhuanlan.zhihu.com/p/151856103

3.分析代码 

不要使用log4j，打印结果不准确

package com.juc.juc;

import lombok.extern.slf4j.Slf4j;
import org.openjdk.jol.info.ClassLayout;

/**
 * @author: @zyz
 */
@Slf4j
public class ObjectHeadTest {
	public static void main (String[] args) throws InterruptedException {
		Thread.sleep (5000);
		ObjectHeadTest objectHeadTest=new ObjectHeadTest ();
//		log.debug ("加锁前");
//		log.debug (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
//		log.debug ("等待加载偏向锁");

		log.debug ("偏向锁");
		log.debug (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
		Thread thread1=new Thread (()->{
			synchronized (objectHeadTest)
			{
				System.out.println (("线程1: 进入synchronized"));
				System.out.println (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
				try {
					Thread.sleep (2000);
				} catch (InterruptedException e) {
					e.printStackTrace ();
				}
			}
		});
		thread1.start ();
		Thread.sleep (2000);
		Thread thread2=new Thread (()->{
			synchronized (objectHeadTest)
			{
				System.out.println (("线程2: 进入synchronized"));
				System.out.println (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
				try {
					Thread.sleep (2000);
				} catch (InterruptedException e) {
					e.printStackTrace ();
				}
			}
		});
		thread2.start ();
		Thread.sleep (1000);
		synchronized (objectHeadTest)
		{
			System.out.println (("main线程: 进入synchronized"));
			System.out.println (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
		}
		System.out.println ("退出锁");
		Thread.sleep (5000);
		System.out.println ("当前处于无锁状态: ");
		System.out.println (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
		System.out.println ("再次进入轻量级锁: ");
		Thread thread3=new Thread (()->{
			synchronized (objectHeadTest)
			{
				System.out.println (("线程3: 进入synchronized"));
				System.out.println (ClassLayout.parseInstance (objectHeadTest).toPrintable ());


			}
		});
		thread3.start ();
		Thread.sleep (5000);
System.out.println (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
		synchronized (objectHeadTest)
		{
			System.out.println (ClassLayout.parseInstance (objectHeadTest).toPrintable ());
		}

	}
}

       结果:

C:\Java\jdk1.8.0_202\bin\java.exe "-javaagent:D:\program\IntelliJ IDEA 2020.2.2\lib\idea_rt.jar=50908:D:\program\IntelliJ IDEA 2020.2.2\bin" -Dfile.encoding=UTF-8 -classpath C:\java\jdk1.8.0_202\jre\lib\charsets.jar;C:\java\jdk1.8.0_202\jre\lib\deploy.jar;C:\java\jdk1.8.0_202\jre\lib\ext\access-bridge-64.jar;C:\java\jdk1.8.0_202\jre\lib\ext\cldrdata.jar;C:\java\jdk1.8.0_202\jre\lib\ext\dnsns.jar;C:\java\jdk1.8.0_202\jre\lib\ext\jaccess.jar;C:\java\jdk1.8.0_202\jre\lib\ext\jfxrt.jar;C:\java\jdk1.8.0_202\jre\lib\ext\localedata.jar;C:\java\jdk1.8.0_202\jre\lib\ext\nashorn.jar;C:\java\jdk1.8.0_202\jre\lib\ext\sunec.jar;C:\java\jdk1.8.0_202\jre\lib\ext\sunjce_provider.jar;C:\java\jdk1.8.0_202\jre\lib\ext\sunmscapi.jar;C:\java\jdk1.8.0_202\jre\lib\ext\sunpkcs11.jar;C:\java\jdk1.8.0_202\jre\lib\ext\zipfs.jar;C:\java\jdk1.8.0_202\jre\lib\javaws.jar;C:\java\jdk1.8.0_202\jre\lib\jce.jar;C:\java\jdk1.8.0_202\jre\lib\jfr.jar;C:\java\jdk1.8.0_202\jre\lib\jfxswt.jar;C:\java\jdk1.8.0_202\jre\lib\jsse.jar;C:\java\jdk1.8.0_202\jre\lib\management-agent.jar;C:\java\jdk1.8.0_202\jre\lib\plugin.jar;C:\java\jdk1.8.0_202\jre\lib\resources.jar;C:\java\jdk1.8.0_202\jre\lib\rt.jar;E:\Java_project\Thread\target\classes;C:\Users\zhang\.m2\repository\org\projectlombok\lombok\1.18.20\lombok-1.18.20.jar;C:\Users\zhang\.m2\repository\ch\qos\logback\logback-classic\1.2.3\logback-classic-1.2.3.jar;C:\Users\zhang\.m2\repository\ch\qos\logback\logback-core\1.2.3\logback-core-1.2.3.jar;C:\Users\zhang\.m2\repository\org\slf4j\slf4j-api\1.7.25\slf4j-api-1.7.25.jar;C:\Users\zhang\.m2\repository\org\openjdk\jmh\jmh-core\1.23\jmh-core-1.23.jar;C:\Users\zhang\.m2\repository\net\sf\jopt-simple\jopt-simple\4.6\jopt-simple-4.6.jar;C:\Users\zhang\.m2\repository\org\apache\commons\commons-math3\3.2\commons-math3-3.2.jar;C:\Users\zhang\.m2\repository\org\openjdk\jol\jol-core\0.8\jol-core-0.8.jar com.juc.juc.ObjectHeadTest
13:08:35.045 [main] DEBUG com.juc.juc.ObjectHeadTest - 偏向锁
13:08:36.386 [main] DEBUG com.juc.juc.ObjectHeadTest - com.juc.juc.ObjectHeadTest object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

线程1: 进入synchronized
com.juc.juc.ObjectHeadTest object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 b0 bb 1f (00000101 10110000 10111011 00011111) (532393989)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

线程2: 进入synchronized
com.juc.juc.ObjectHeadTest object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 b0 bb 1f (00000101 10110000 10111011 00011111) (532393989)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

main线程: 进入synchronized
com.juc.juc.ObjectHeadTest object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           ca 1a 5a 1c (11001010 00011010 01011010 00011100) (475667146)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

退出锁
当前处于无锁状态: 
com.juc.juc.ObjectHeadTest object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           ca 1a 5a 1c (11001010 00011010 01011010 00011100) (475667146)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

再次进入轻量级锁: 
线程3: 进入synchronized
com.juc.juc.ObjectHeadTest object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           ca 1a 5a 1c (11001010 00011010 01011010 00011100) (475667146)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

com.juc.juc.ObjectHeadTest object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

com.juc.juc.ObjectHeadTest object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           10 f8 7a 02 (00010000 11111000 01111010 00000010) (41613328)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           05 c1 00 f8 (00000101 11000001 00000000 11111000) (-134168315)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total


Process finished with exit code 0

       测试结果表明了,只有批量重偏向和第一次给对象加锁时会为对象添加偏向锁,当对象上的锁被释放后，不会再为其添加偏向锁，而是直接添加轻量级锁，没有重偏向这一说法，只有批量重偏向的概念。

技术无产者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized 实现原理
流楚丶格念的博客
08-17 3836
两种同步方式本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。两个指令的执行是JVM通过调用操作系统的互斥原语mutex来实现，被阻塞的线程会被挂起、等待重新调度，会导致“用户态和内核态”两个态之间来回切换，对性能有较大影响。synchronized关键字经过Javac编译之后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令。这两个字节码指令都需要一个reference类型的参数来指明要锁定和解锁的对象。......
Synchronized的底层实现原理（原理解析，面试必备）
weixin_42460087的博客
08-22 2万+
synchronize的底层实现原理和monitor的实现机制
Synchronized的底层实现原理(看这篇就够了)
热门推荐
mikechen的互联网架构
01-12 2万+
谈到多线程就不得不谈到Synchronized，重要性不言而喻，今天主要分享Synchronized的底层实现。 标题Synchronized synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized 翻译为中文的意思是同步，也称之为”同步锁“。 synchronized的作用是保证在同一时刻， 被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。 标题Synchronized的使用方式 主要有3种使用方式: 1.修饰实例方法：作用于当前实例加锁 pu.
图文详解：synchronized关键字 及其底层原理
最新发布
luming的博客
05-13 1283
本文旨在分享如何解决线程安全问题，通过详细的解释和图示讲解了Java中的synchronized关键字的使用方法和具体细节，Java标准库中对于synchronized的使用。 线程安全是指在多线程环境下，对共享资源的访问不会导致数据不一致或出现意外结果的特性。在多线程程序中，多个线程可以同时访问和操作共享数据，如果没有适当的同步机制和保护措施，可能会导致数据竞争和不一致的问题。
synchronized底层实现原理（保证看懂）
成都彭于晏
02-02 8364
首先那些说看过synchronized源码的基本都是大聪明，synchronized根本点不进去，想弄懂它的实现原理，我们只能通过看编译好的字节码文件 整个测试类 public class SynchronizedTest { public void get() { synchronized (this) { System.out.println("小张你好鸭！"); } } } 字节码文件（怎么看？？ idea => view
复习synchronized之底层原理
01-20
synchronized是什么 关键字，Java利用锁机制实现线程同步的一种方式。 Java实现线程同步的方式： 1.显式锁（lock，需要自己写代码去获取锁和释放锁）； 2.隐式锁（synchronized，自动的）。 synchronized的保证的...
Java并发底层实现原理学习心得
08-28
总的来说，理解和掌握Java并发底层实现原理，如volatile和synchronized的细节，对于编写高效、线程安全的代码至关重要。这涉及到JVM内存模型、锁的状态转换以及指令层面的实现，这些都是提升并发编程能力的基础。...
Java并发编程：Synchronized及其实现原理
12-22
以下将详细介绍Synchronized的使用及其实现原理。 一、Synchronized基本使用 1. 修饰普通方法 当Synchronized用于修饰非静态方法时，它会为每个对象实例创建一个锁，也称为实例锁或对象锁。当线程A调用该对象的...
深入理解Java并发之synchronized实现原理.docx
06-27
synchronized的底层语义原理涉及到Java对象头和Monitor。Monitor是一种数据结构，用于实现锁机制。在Java对象头中，包含了一个指向Monitor的指针，当线程尝试进入同步代码块或方法时，如果锁未被持有，线程会被阻塞...
synchronized底层实现原理
罗彬桦的博客
05-22 687
synchronized底层实现原理 实现synchronized的基础 Java对象头 Monitor 对象在内存中的布局 对象头 实例数据 对齐填充 对象头的结构 Mark Word
synchronized底层原理
m0_51380306的博客
12-21 453
synchronized底层原理 前言 无锁 偏向锁 偏向锁的工作原理 重偏向 批量重偏向 其他规则 轻量级锁 初衷 CAS 具体实现 重量级锁 文章已收录我的仓库：Java学习笔记与免费书籍分享 synchronized底层原理 前言 在JDK1.5之前，synchronized的实现是依赖于操作系统的，采用的是一种悲观的机制，必须严格保证资源的安全性，因此无论是否存在并发问题，都必须严格的经过获取锁操作，获取锁必须切换至内核态，而当线程尝试获取失败后，必须挂起线程然后切换，休眠或切.
synchronized原理
纯洁的小魔鬼
05-11 4358
一.synchronized简介 1.java中的关键字，在JVM层面，Java利用锁机制实现线程同步的一种方式。 2.synchronized属于隐式锁，相比于显示锁如ReentrantLock不需要自己写代码去获取锁和释放锁。 3.synchronized属于可重入锁，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。即 synchronized块中的synchronized还是能马上获得该锁。 4.synchronized为非公平锁，即多个线程去获取锁...
一篇就够，synchronized原理详解
小派师兄
11-19 1万+
synchronized详解 在多线程同时访问一个共享变量时，volatile是一个轻量级的解决方案，但是volatile只能修饰一个变量并且不保证原子性。在Java中还提供了两种方式实现同步互斥访问：synchronized和Lock 其实这些本质上就是加锁， 加锁目的:序列化访问临界资源，即同一时刻只能有一个线程访问临界资源(同步互斥访问) 不过有一点需要区别的是:当多个线程执行一个方法时，该方法内部的局部变量并不是临界资源，因为这些局部变量是在每个线程的 私有栈中，因此不具有共享性，不会导致线程安全
synchronized的底层实现原理及各种优化
博客
05-12 8598
synchronized实现原理及优化 几个概念： 并发 并行 同步 线程安全 synchronized概述 synchronized，单词译为同步，是Java的内建锁，用来确保线程安全，是解决并发问题的一种重要手段。synchronized可以保证在多线程状态下，每次仅有一个线程访问共享资源。 synchronized的作用主要有一下三个： 原子性：线程互斥的访问同步代码块。 可见性：sync...
Synchronized底层实现原理
Maoiur的博客
01-13 252
Java对象底层都关联monitor，使用synchronized时jvm会根据使用环境找到对象的monitor。根据monitor的状态加解锁的判断。如果成功加锁就成为monitor的唯一持有者。Monitor在被释放前不能被其他线程获取。 Synchronized在jvm编码后会产生monitorenter和monitorexit这两个字节码指令，获取和释放monitor。这两个字节码指令都需要引用类型的参数指明要锁定和解锁的对象，对于普通同步方法，锁是当前实例对象；对...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值