synchronized关键字

最新推荐文章于 2024-05-21 15:37:32 发布

我橘子超酸

最新推荐文章于 2024-05-21 15:37:32 发布

阅读量154

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/Sour_orange/article/details/118876857

版权

Java基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

使用方式

首先说一下如何使用synchronized关键字

从被锁定的对象看（锁类实际上是锁Class对象，每个类在jvm中都对应一个Class对象）

1 锁实例对象：放在成员方法上或者在同步代码块中指定锁定的对象实例
2 锁类：放在类方法上或者在同步代码块中指定锁定的类
从使用的位置看

1 修饰成员方法
2 修饰类方法
3 修饰同步代码块

	//修饰成员方法，锁对象1
    public synchronized void fun1() {

    }
    //修饰类方法，锁类
    public static synchronized void fun2() {

    }
    //修饰同步代码块，锁定指定的对象
    public void fun3() {
    	//锁定this对象
        synchronized (this) {
            
        }
        //锁定A类
         synchronized (A.class) {
            
        }
    }

作用范围

类锁和对象锁相互不影响
比如线程1获取的类A的类锁，其他的线程照样可以使用该类的各种成员方法。反之同理。
理解：因为synchronized锁本质是获取对象的锁，而类锁是Class对象的锁（A.class这个对象），对象锁是某个实例的锁(a 这个对象)
```
	A a = new A();
	synchronized (a) {
	
	}
	synchronized (A.class) {
	
	}
```
同步方法与非同步方法

同步方法不会影响非同步方法的使用
即一个线程获取的某个对象的锁之后，其他线程仍然能够通过该对象访问非同步方法。
同步方法影响同步方法
即一个线程获取到某个对象锁之后，其他线程不能再调用其他同步方法

将上述两点互不冲突，组合使用。
因篇幅考虑，只给出了结论，示例可参考下文
参考：点击直达

原理

上文说过synchronized锁实际上是锁的对象，下面介绍Java对象组成，以便理解这一概念

Java对象组成

我们都知道对象是放在堆内存中的，对象大致可以分为三个部分，分别是：对象头，实例变量和填充字节 在这里插入图片描述

对象头，主要包括两部分：1.Mark Word（标记字段），2.Klass Pointer（类型指针）。Mark Word用于存储对象自身的运行时数据。Klass Point是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例(即指向方法区类的模板信息)。
实例变量，存放类的属性数据信息，包括父类的属性信息，这部分内存按4字节对齐
填充数据，由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐
假如有如下的类，a=100这个信息就存储在实例变量中

public class Test {
    int a = 100;
}

填充数据主要是为了方便内存管理，如你想要10字节的内存，但是会给你分配16字节的内存，多出来的字节就是填充数据

锁在哪里？

synchronized无论是修饰方法还是修饰代码块，都是通过持有修饰对象的锁来实现同步的，上文所说的锁类锁对象即通过持有类对象的锁或持有实例对象的锁。
那么synchronized锁对象是存在于锁对象对象头Mark Word，来看一下Mark Word存储了哪些内容？

由于对象头的信息是与对象自身定义的数据没有关系的额外存储成本，因此考虑到JVM的空间效率，Mark Word 被设计成为一个非固定的数据结构，以便存储更多有效的数据，它会根据对象本身的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，变化状态如下 (32位虚拟机)：在这里插入图片描述
其中轻量级锁和偏向锁是Java 6 对 synchronized 锁进行优化后新增加的，稍后我们会简要分析。这里我们主要分析一下重量级锁也就是通常说synchronized的对象锁，锁标识位为10，其中指针指向的是monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个 monitor 与之关联。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp文件，C++实现的），省略部分属性

ObjectMonitor() {
    _count        = 0; //记录数
    _recursions   = 0; //锁的重入次数
    _owner        = NULL; //指向持有ObjectMonitor对象的线程 
    _WaitSet      = NULL; //调用wait后，线程会被加入到_WaitSet
    _EntryList    = NULL ; //等待获取锁的线程，会被加入到该列表
}

在这里插入图片描述
结合线程状态解释一下执行过程。(状态装换参考自《深入理解Java虚拟机》)

1.新建（New），新建后尚未启动的线程
2. 运行（Runable），Runnable包括了操作系统线程状态中的Running和Ready
3. 无限期等待（Waiting），不会被分配CPU执行时间，要等待被其他线程显式的唤醒。例如调用没有设置Timeout参数的Object.wait()方法
4. 限期等待（Timed Waiting），不会被分配CPU执行时间，不过无需等待其他线程显示的唤醒，在一定时间之后会由系统自动唤醒。例如调用Thread.sleep()方法
5. 阻塞（Blocked），线程被阻塞了，“阻塞状态”与“等待状态”的区别是：“阻塞状态”在等待获取着一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生，而“等待状态”则是在等待一段时间，或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将进入这种状态
6. 结束（Terminated）：线程结束执行
在这里插入图片描述

对于一个synchronized修饰的方法(代码块)来说：
1. 当多个线程同时访问该方法，那么这些线程会先被放进_EntryList队列，此时线程处于blocked状态
2. 当一个线程获取到了对象的monitor后，那么就可以进入running状态，执行方法，此时，ObjectMonitor对象的/_owner指向当前线程，_count加1表示当前对象锁被一个线程获取
3. 当running状态的线程调用wait()方法，那么当前线程释放monitor对象，进入waiting状态，ObjectMonitor对象的/_owner变为null，_count减1，同时线程进入_WaitSet队列，直到有线程调用notify()方法唤醒该线程，则该线程进入_EntryList队列，竞争到锁再进入_Owner区
4. 如果当前线程执行完毕，那么也释放monitor对象，ObjectMonitor对象的/_owner变为null，_count减1

由此看来，monitor对象存在于每个Java对象的对象头中(存储的是指针)，synchronized锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因，同时也是notify/notifyAll/wait等方法存在于顶级对象Object中的原因

synchronized如何获取monitor对象？

先说结论：
修饰代码块时：Code:段中
monitorenter // 进入同步方法
monitorexit // 退出同步方法
修饰方法时：flags:段中
ACC_SYNCHRONIZED
代码：

class MyThread {

    public static void main(String[] args) throws InterruptedException {

    }

    public static synchronized void fun1() {
        System.out.println("This is fun1");
    }

    public synchronized void fun2() {
        System.out.println("This is fun2");
    }

    public static void fun3 () {
        boolean[] b = new boolean[0];
        synchronized (b) {
            System.out.println("This is fun3");
        }
    }
    
    public void fun4() {
        synchronized (this) {
            System.out.println("This is fun4");
        }
    }
}

反编译后

Compiled from "MyThread.java"
class MyThread {
  MyThread();
  public static void main(java.lang.String[]) throws java.lang.InterruptedException;
  public static synchronized void fun1();
  public synchronized void fun2();
  public static void fun3();
  public void fun4();
}
PS D:\java> javap -v MyThread.class
Classfile /D:/java/MyThread.class
  Last modified 2021-7-17; size 948 bytes
  MD5 checksum cc58573f16e6a46396634152b7da5d75
  Compiled from "MyThread.java"
class MyThread
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Methodref          #9.#29         // java/lang/Object."<init>":()V
   #2 = Fieldref           #30.#31        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #32            // This is fun1
   #4 = Methodref          #33.#34        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = String             #35            // This is fun2
   #6 = String             #36            // This is fun3
   #7 = String             #37            // This is fun4
   #8 = Class              #38            // MyThread
   #9 = Class              #39            // java/lang/Object
  #10 = Utf8               <init>
  #11 = Utf8               ()V
  #12 = Utf8               Code
  #13 = Utf8               LineNumberTable
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               Exceptions
  #17 = Class              #40            // java/lang/InterruptedException
  #18 = Utf8               fun1
  #19 = Utf8               fun2
  #20 = Utf8               fun3
  #21 = Utf8               StackMapTable
  #22 = Class              #41            // "[Z"
  #23 = Class              #39            // java/lang/Object
  #24 = Class              #42            // java/lang/Throwable
  #25 = Utf8               fun4
  #26 = Class              #38            // MyThread
  #27 = Utf8               SourceFile
  #28 = Utf8               MyThread.java
  #29 = NameAndType        #10:#11        // "<init>":()V
  #30 = Class              #43            // java/lang/System
  #31 = NameAndType        #44:#45        // out:Ljava/io/PrintStream;
  #32 = Utf8               This is fun1
  #33 = Class              #46            // java/io/PrintStream
  #34 = NameAndType        #47:#48        // println:(Ljava/lang/String;)V
  #35 = Utf8               This is fun2
  #36 = Utf8               This is fun3
  #37 = Utf8               This is fun4
  #38 = Utf8               MyThread
  #39 = Utf8               java/lang/Object
  #40 = Utf8               java/lang/InterruptedException
  #41 = Utf8               [Z
  #42 = Utf8               java/lang/Throwable
  #43 = Utf8               java/lang/System
  #44 = Utf8               out
  #45 = Utf8               Ljava/io/PrintStream;
  #46 = Utf8               java/io/PrintStream
  #47 = Utf8               println
  #48 = Utf8               (Ljava/lang/String;)V
{
  MyThread();
    descriptor: ()V
    flags:
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 1: 0

  public static void main(java.lang.String[]) throws java.lang.InterruptedException;
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=0, locals=1, args_size=1
         0: return
      LineNumberTable:
        line 5: 0
    Exceptions:
      throws java.lang.InterruptedException

  public static synchronized void fun1();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String This is fun1
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 8: 0
        line 9: 8

  public synchronized void fun2();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #5                  // String This is fun2
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 12: 0
        line 13: 8

  public static void fun3();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=3, args_size=0
         0: iconst_0
         1: newarray       boolean
         3: astore_0
         4: aload_0
         5: dup
         6: astore_1
         7: monitorenter
         8: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        11: ldc           #6                  // String This is fun3
        13: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        16: aload_1
        17: monitorexit
        18: goto          26
        21: astore_2
        22: aload_1
        23: monitorexit
        24: aload_2
        25: athrow
        26: return
      Exception table:
         from    to  target type
             8    18    21   any
            21    24    21   any
      LineNumberTable:
        line 16: 0
        line 17: 4
        line 18: 8
        line 19: 16
        line 20: 26
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 21
          locals = [ class "[Z", class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4

  public void fun4();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter
         4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: ldc           #7                  // String This is fun4
         9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        12: aload_1
        13: monitorexit
        14: goto          22
        17: astore_2
        18: aload_1
        19: monitorexit
        20: aload_2
        21: athrow
        22: return
      Exception table:
         from    to  target type
             4    14    17   any
            17    20    17   any
      LineNumberTable:
        line 23: 0
        line 24: 4
        line 25: 12
        line 26: 22
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 17
          locals = [ class MyThread, class java/lang/Object ]
          stack = [ class java/lang/Throwable ]
        frame_type = 250 /* chop */
          offset_delta = 4
}
SourceFile: "MyThread.java"

进入同步代码块，执行monitorenter指令，退出同步代码块，执行monitorexit指令，可以看到有2个monitorexit指令，第一个是正常退出执行的，第二个是当异常发生时执行的

锁升级过程

偏向锁

为什么要引入偏向锁？

因为经过HotSpot的作者大量的研究发现，大多数时候是不存在锁竞争的，常常是一个线程多次获得同一个锁，因此如果每次都要竞争锁会增大很多没有必要付出的代价，为了降低获取锁的代价，才引入的偏向锁。

偏向锁原理和升级过程

当线程1访问代码块并获取锁对象时，会在java对象头和栈帧中记录偏向的锁的threadID，因为偏向锁不会主动释放锁，因此以后线程1再次获取锁的时候，需要比较当前线程的threadID和Java对象头中的threadID是否一致，如果一致（还是线程1获取锁对象），则无需使用CAS来加锁、解锁；如果不一致（其他线程，如线程2要竞争锁对象，而偏向锁不会主动释放因此还是存储的线程1的threadID），那么需要查看Java对象头中记录的线程1是否存活，如果没有存活，那么锁对象被重置为无锁状态，其它线程（线程2）可以竞争将其设置为偏向锁；如果存活，那么立刻查找该线程（线程1）的栈帧信息，如果还是需要继续持有这个锁对象，那么暂停当前线程1，撤销偏向锁，升级为轻量级锁，如果线程1 不再使用该锁对象，那么将锁对象状态设为无锁状态，重新偏向新的线程。

轻量级锁

为什么要引入轻量级锁？

轻量级锁考虑的是竞争锁对象的线程不多，而且线程持有锁的时间也不长的情景。因为阻塞线程需要CPU从用户态转到内核态，代价较大，如果刚刚阻塞不久这个锁就被释放了，那这个代价就有点得不偿失了，因此这个时候就干脆不阻塞这个线程，让它自旋这等待锁释放。

轻量级锁原理和升级过程

线程1获取轻量级锁时会先把锁对象的对象头MarkWord复制一份到线程1的栈帧中创建的用于存储锁记录的空间（称为DisplacedMarkWord），然后使用CAS把对象头中的内容替换为线程1存储的锁记录（DisplacedMarkWord）的地址；

如果在线程1复制对象头的同时（在线程1CAS之前），线程2也准备获取锁，复制了对象头到线程2的锁记录空间中，但是在线程2CAS的时候，发现线程1已经把对象头换了，线程2的CAS失败，那么线程2就尝试使用自旋锁来等待线程1释放锁。自旋锁简单来说就是让线程2在循环中不断CAS

但是如果自旋的时间太长也不行，因为自旋是要消耗CPU的，因此自旋的次数是有限制的，比如10次或者100次，如果自旋次数到了线程1还没有释放锁，或者线程1还在执行，线程2还在自旋等待，这时又有一个线程3过来竞争这个锁对象，那么这个时候轻量级锁就会膨胀为重量级锁。重量级锁把除了拥有锁的线程都阻塞，防止CPU空转。

正确加锁姿势

// 普通对象锁
private final Object lock = new Object();
// 静态对象锁
private static final Object lock = new Object();

我橘子超酸

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
synchronized关键字

目录使用方式作用范围原理Java对象组成锁在哪里？synchronized如何获取monitor对象？锁升级过程偏向锁为什么要引入偏向锁？偏向锁原理和升级过程轻量级锁为什么要引入轻量级锁？轻量级锁原理和升级过程正确加锁姿势众所周知并发编程的三大特性：可见性、原子性、有序性。而synchronized能够同时保证可见性、原子性、有序性。且在Java 6 版本对synchronized关键字进行种种优化后性能大增。因此在解决并发问题时会经常用到synchronized关键字。使用方式首先说一下如何使用s
复制链接

扫一扫