Java多线程：线程同步（3）- synchronized关键字

已于 2023-07-13 23:14:51 修改
阅读量2.2k 收藏 12
点赞数 32
分类专栏： Java 文章标签： java
于 2022-04-19 21:38:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lhm964517471/article/details/124284263
版权

🍇一、synchronized

1. 介绍

synchronize是Java中的关键字，可以用在实例方法、静态方法、同步代码块。synchronize解决了：原子性、可见性、有序性三个问题，用来保证多线程环境下共享变量的正确性。

🥇原子性：执行被synchronized修饰的方法和代码块，都必须要先获得类或者对象锁，执行完之后再释放锁，中间是不会中断的，这样就保证了原子性。

🥈可见性：执行被synchronized修饰的方法和代码块，一个线程获得了锁，执行完毕之后， 在释放锁之前，会对变量的修改同步回内存中，对其它线程是可见的。

🥉有序性：synchronized保证了每个时刻都只有一个线程访问同步代码块或者同步方法，这样就相当于是有序的。

2. 使用示例

用一个示例来展示synchronized的用法，现在有两个线程，对一个变量进行自增10000000次操作，在正确的情况下，最后的结果应该是20000000。但是实际使用过程中可能会出现各种情况。

public class MainDemo extends Thread {
    private static int increment = 0;

    @Override
    public void run () {
        for (int i = 0; i < 10000000; i++) {
            increment++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MainDemo mainDemo = new MainDemo();
        Thread t1 = new Thread(mainDemo);
        Thread t2 = new Thread(mainDemo);
        t1.start();
        t2.start();
        // 阻塞主线程，直到t1和t2运行完毕
        t1.join();
        t2.join();
        System.out.println(increment);
    }
}

2.1. 修饰普通方法

synchronized修饰普通方法只需要在方法上加上synchronized即可。synchronized修饰的方法，如果子类重写了这个方法，子类也必须加上synchronized关键字才能达到线程同步的效果。

public class MainDemo extends Thread {
    private static int increment = 0;

    @Override
    public void run () {
        for (int i = 0; i < 10000000; i++) {
            incrementMethod();
        }
    }

    public synchronized void incrementMethod() {
        increment++;
    }

    public static void main(String[] args) throws InterruptedException {
        MainDemo mainDemo = new MainDemo();
        Thread t1 = new Thread(mainDemo);
        Thread t2 = new Thread(mainDemo);
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(increment);
    }
}

2.2. 修饰静态方法

当synchronized作用于静态方法时，和实例方法类似，只需要在静态方法上面加上synchronized关键字即可。

public class MainDemo extends Thread {
    private static int increment = 0;

    @Override
    public void run () {
        for (int i = 0; i < 10000000; i++) {
            incrementMethod();
        }
    }

    public static synchronized void incrementMethod() {
        increment++;
    }

    public static void main(String[] args) throws InterruptedException {
        MainDemo mainDemo = new MainDemo();
        Thread t1 = new Thread(mainDemo);
        Thread t2 = new Thread(mainDemo);
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(increment);
    }
}

2.3. 修饰同步代码块

修饰同步代码块可以使用：类对象和实例对象，但是要保证唯一性，多个线程使用的对象要是同一个对象。唯一性的意思就是说下面的objectLock必须是同一个对象，如果每个线程都新建一个对象，那么就达不到保证线程安全的效果。

public class MainDemo extends Thread {
    private static int increment = 0;

    private static Object objectLock = new Object();

    @Override
    public void run () {
        for (int i = 0; i < 10000000; i++) {
            synchronized (objectLock) {
                increment++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MainDemo mainDemo = new MainDemo();
        Thread t1 = new Thread(mainDemo);
        Thread t2 = new Thread(mainDemo);
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(increment);
    }
}

3. 虚拟机标记

synchronized可以保证线程安全，那么虚拟机是如何识别synchronized的呢？

在Java虚拟机层面标记synchronized修饰的代码有两种方式：

🥇ACC_SYNCHRONIZED标识位

🥈monitorenter和monitorexit指令

3.1 同步代码块

当synchronized修饰同步代码块的时候。

public class MainDemo extends Thread {
    private static int increment = 0;

    private static Object objectLock = new Object();

    @Override
    public void run () {
        for (int i = 0; i < 10000000; i++) {
            synchronized (objectLock) {
                increment++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        MainDemo mainDemo = new MainDemo();
        Thread t1 = new Thread(mainDemo);
        Thread t2 = new Thread(mainDemo);
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(increment);
    }
}

我们先编译这个类，然后再反编译反编译。

// 编译
javac MainDemo.java
// 反编译
javap -v MainDemo.class

反编译之后输出如下内容，我们可以看到在13行和23行有monitorenter和monitorexit两个指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令则指明同步代码块的结束位置，当执行monitorenter指令的时候需要去获取对象锁，执行monitorexit的时候释放对象锁。

  public void run();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         0: iconst_0
         1: istore_1
         2: iload_1
         3: ldc           #2                  // int 10000000
         5: if_icmpge     38
         8: getstatic     #3                  // Field objectLock:Ljava/lang/Object;
        11: dup
        12: astore_2
        13: monitorenter
        14: getstatic     #4                  // Field increment:I
        17: iconst_1
        18: iadd
        19: putstatic     #4                  // Field increment:I
        22: aload_2
        23: monitorexit
        24: goto          32
        27: astore_3
        28: aload_2
        29: monitorexit
        30: aload_3
        31: athrow
        32: iinc          1, 1
        35: goto          2
        38: return

3.2. 同步方法

当synchronized修饰实例方法或者静态方法的时候。

public class MainDemo extends Thread {
    private static int increment = 0;

    @Override
    public void run () {
        for (int i = 0; i < 10000000; i++) {
            incrementMethod();
        }
    }

    public synchronized void incrementMethod() {
        increment++;
    }

    public static void main(String[] args) throws InterruptedException {
        MainDemo mainDemo = new MainDemo();
        Thread t1 = new Thread(mainDemo);
        Thread t2 = new Thread(mainDemo);
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(increment);
    }
}

我们先编译这个类，然后再反编译反编译。

// 编译
javac MainDemo.java
// 反编译
javap -v MainDemo.class

无论是实例方法还是静态方法，实现都是通过ACC_SYNCHRONIZED标识，反编译之后可以看到在方法上有ACC_SYNCHRONIZED标识，表明这是一个同步方法，线程执行这个方法的时候都会先去获取对象锁，方法执行完毕之后会释放对象锁。

public synchronized void incrementMethod();
descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
stack=2, locals=1, args_size=1
    0: getstatic     #4                  // Field increment:I
    3: iconst_1
    4: iadd
    5: putstatic     #4                  // Field increment:I
    8: return
    LineNumberTable:
line 13: 0
    line 14: 8

🍉二、底层实现

1. 对象结构

实例对象在内存中的结构分了三个部分：对象头、实例数据、对齐填充。对象头又包含了：标记字段Mark Word、类型指针KlassPointer、长度Length field三个部分。

  • 对象头：存储了锁状态标志、线程持有的锁等标志。

    • 标记字段Mark Word：用于存储对象自身的运行时数据，他是经过轻量级锁和偏向锁的关键
    • 类型指针KlassPointer：是对象指向他的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例
    • 长度Length field：如果是数组对象，对象头还包含了数组长度。

  • 实例数据：对象真正存储的有效信息，存放类的属性数据信息。

  • 对齐填充：对齐填充不是必须存在的，仅仅时让对象的长度达到8字节的整数倍，其中一个原因就是为了不让对象数据跨缓存行，用空间换时间。

在这里插入图片描述

2. Mark Word结构

Mark word主要用于存储对象在运行时自身的一些数据，比如GC信息、锁信息等。在64位虚拟机中Mark Word的结构如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lORGkcDC-1689059958951)在这里插入图片描述

3. 查看对象头结构数据

3.1. 引入相关的jar包

首先导入相关的包

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

3.2. 示例代码

public class SynDemo {
    public static void main(String[] args) {
        Object object = new Object();
        System.out.println(Integer.toString(object.hashCode(), 2));
        System.out.println(ClassLayout.parseInstance(object).toPrintable());
    }
}

3.3. 对象头数据

hashcode: 10111101001111100111011000010
java.lang.Object object internals:
OFFSET SIZE  TYPE DESCRIPTION                               VALUE
  0     4        (object header)  01 c2 ce a7 (00000001 11000010 11001110 10100111) 
  4     4        (object header)  17 00 00 00 (00010111 00000000 00000000 00000000)
  8     4        (object header)  e5 01 00 f8 (11100101 00000001 00000000 11111000) 
 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.4. Mark Word分析

从对象头的结构可以得知，Mark word的大小为8个字节，那么我们输出的对象头数据的前两行就是``Mark word的内容，其中value就是Mark word的数据。同时我们也输出了对象头的hashcode`值，用于对比。

OFFSET SIZE  TYPE DESCRIPTION                               VALUE
  0     4        (object header)  01 c2 ce a7 (00000001 11000010 11001110 10100111) 
  4     4        (object header)  17 00 00 00 (00010111 00000000 00000000 00000000)

Mark word值分了两种格式输出，前面是十六进制的，后面是二进制的，我们输出的hashcode值是：10111101001111100111011000010，对象头的hashcode是31位的，补全之后的hashcode值：0010111101001111100111011000010 从二进制中好像是找不到对应的数据，下面做一个处理。

在这里插入图片描述

如下图我们将上面的二进制按照倒叙排列，图中红色方框内的数据就和hashcode值完全对应上了，再结合对象头Mark word结构，最后两位绿框就是锁的标识位。

在这里插入图片描述

4. 如何实现

synchronized是借助Java对象头来实现的，通过对象头的介绍，可以知道，对象头的Mark word里的数据是在变化的，不同的数据表示了不同类型的锁，而synchronized就是通过获取这些锁来实现线程安全的。

前面我们说了当我们使用synchronized来保证线程安全的时候，虚拟机在编译代码的时候，会添加标记：ACC_SYNCHRONIZED和monitorenter、monitorexit指令。

当虚拟机执行代码的时候，如果发现了这些标记，那么就会让线程去获取对象锁，也就是去修改对象头的数据，只有获取到锁的线程才能继续执行代码，其它的线程则需要等待，直到获取锁的线程释放锁。

🍏三、锁升级过程

在1.6之前，synchronized只有重量级锁，在1.6版本对synchronized锁进行了优化，有了偏向锁，轻量级锁。

由此锁升级有四种状态：无锁，偏向锁，轻量级锁，重量级锁。锁升级是不可逆的，只能升级不能降级。

锁的升级是通过对象头的Mark word的数据变化来完成的，数据会根据锁变化而变化。

1. 无锁

1.1 Mark Word结构

无锁就是没有线程来抢站对象头这个时候的Mark word的数据如下：

锁状态25bit31bit1bit4bit1bit 是否偏向锁2bit 锁标识位
无锁unused对象的hashcodeunused分代年龄001

1.2. 对象头结构数据

public class SynDemo {
    public static void main(String[] args) {
        Object object = new Object();
        System.out.println(Integer.toString(object.hashCode(), 2));
        System.out.println(ClassLayout.parseInstance(object).toPrintable());
    }
}

可以看到无锁的时候对象头最后八位的数据是00000001，标识锁的两位是01。

hashcode: 10111101001111100111011000010
java.lang.Object object internals:
OFFSET SIZE  TYPE DESCRIPTION                               VALUE
  0     4        (object header)  01 c2 ce a7 (00000001 11000010 11001110 10100111) 
  4     4        (object header)  17 00 00 00 (00010111 00000000 00000000 00000000)
  8     4        (object header)  e5 01 00 f8 (11100101 00000001 00000000 11111000) 
 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. 偏向锁

2.1 Mark Word结构

偏向锁的Mark word锁标志位和无锁一样是01，是否偏向锁是1

锁状态54bit2bit4bit1bit 是否偏向锁2bit 锁标识位
无锁unused对象的hashcode分代年龄101

2.2 什么是偏向锁

偏向锁主要是来优化同一个线程多次获取同一个锁的，有时候线程t在执行同步代码的时候先去获取锁，执行完了之后不会释放锁，然后第二次线程t第二次执行同步代码的时候先去获取锁，发现Mark word的线程ID就是它，就不需要重新加锁。

在JDK1.6之后是默认开启偏向锁的，但是我们在使用的时候是绕过偏向锁了直接进入轻量级锁，这是因为虽然默认开启了偏向锁，但是开启是有延迟的，大概是4s钟，也即是程序刚启动创建的对象是不会开启偏向锁的，4秒之后创建的对象才会开启，可以通过JVM参数来设置延迟时间。

//关闭延迟开启偏向锁
-XX:BiasedLockingStartupDelay=0
//禁止偏向锁
-XX:-UseBiasedLocking 
//启用偏向锁
-XX:+UseBiasedLocking

在JDK15中偏向锁已经被标记为Deprecate

2.3 加锁过程

线程获取偏向锁的过程，当线程执行被synchronized修饰的同步代码块的时候

1.检查锁标志位是否是01

2.检查是否是偏向锁

3.如果不是偏向锁，直接通过CAS替换Mark word的线程ID为当前线程ID，并修改是否偏向锁为1

4.如果是偏向锁，检查Mark word的线程ID是否是当前线程的ID，如果是的话直接就执行同步代码块，如果不是当前线程的线程ID也是通过CAS替换Mark word的线程ID为当前线程ID

5.CAS成功之后便执行同步代码

2.4 锁升级过程

上面我们说在加锁的过程中都是通过CAS操作替换Mark word的线程ID为当前线程的ID，如果CAS失败了就可能会升级为轻量级锁

1.当CAS失败的时候，原持有偏向锁到达线程安全点的时候

2.检查原持有偏向锁的线程的线程状态

3.如果原持有偏向锁的线程还没有退出同步代码块就升级为轻量级锁，并且仍然由原线程持有轻量级锁

4.如果原持有偏向锁的线程已经退出同步代码块了，偏向锁撤销Mark word的线程ID更新为空，是否偏向改为0

5.如果原线程不竞争锁，则偏向锁偏向后来的线程，如果原线程要竞争锁，则升级为轻量级锁

如果调用了对象的hashcode方法或者执行了wait和 notify方法，锁升级为重量级锁。

2.2 对象头结构数据

设置睡眠时间为5秒，这样才会进入偏向锁，只有一个线程来竞争锁，所以会转向偏向锁

public class SynDemo  {
    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(5000);
        SynDemo synDemo = new SynDemo();
        synchronized (synDemo) {
            System.out.println(ClassLayout.parseInstance(synDemo).toPrintable());
        }
    }
}

这里只有一个线程在竞争锁，所以锁就是偏向锁，锁标志位是01，是否偏向是1。

 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
  0     4        (object header)       05 88 80 54 (00000101 10001000 10000000 01010100) 
  4     4        (object header)       c2 7f 00 00 (11000010 01111111 00000000 00000000) 
  8     4        (object header)       05 c1 00 f8 (00000101 11000001 00000000 11111000)

3. 轻量级锁

3.1 Mark Word结构

锁状态62bit2bit
轻量级锁指向线程栈中的Lock Record指针00

3.2什么是轻量级锁

当偏向锁，被另外的线程访问的时候，偏向锁就会升级为轻量级锁，其它线程会通过自旋的形式尝试获取锁，不会阻塞线程，从而提高了性能。

3.3 加锁过程

1.在当前线程的栈帧中建立一个名为锁记录Lock Record空间

2.拷贝对象头的Mark word到锁记录空间，这个拷贝的过程官方称为Displaced Mark Word

3.使用CAS操作把Mark Word中的指针指向线程的锁记录空间，更新锁标志位为00

4.当线程持有偏向锁并且偏向锁升级为轻量级锁，

5.如果线程是持有偏向锁升级为轻量级锁那么不用通过CAS获取锁，而是直接持有锁

3.4 释放锁

当线程执行完同步代码块的时候，就会释放锁

1.用CAS操作把对象当前的Mark Word和线程中复制的Displaced Mark Word替换回来

2.如果替换成功，同步过程就完成了

3.如果替换不成功，说明有其它线程尝试获取该锁，就要在释放锁的同时，唤醒被挂起的线程

3.5 锁升级过程

当线程通过CAS获取轻量级锁，如果CAS的次数过多，没有获取到轻量级锁，那么锁就会升级为重量级锁。

除此之外一个线程在持有锁，一个在自旋，又有第三个线程来竞争锁，轻量级锁升级为重量级锁。

次数

3.6 对象头结构数据

public class SynDemo  {
    public static void main(String[] args) throws InterruptedException {
        SynDemo synDemo = new SynDemo();
        Thread t1 = new Thread(() -> {
            synchronized (synDemo) {
                System.out.println(ClassLayout.parseInstance(synDemo).toPrintable());
            }
        });
        t1.start();
    }
}

OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
  0     4        (object header)      08 49 20 11 (00001000 01001001 00100000 00010001)
  4     4        (object header)      00 70 00 00 (00000000 01110000 00000000 00000000)
  8     4        (object header)      05 c1 00 f8 (00000101 11000001 00000000 11111000)

4. 重量级锁

4.1 Mark word结构

锁状态62bit2bit
轻量级锁指向互斥量的指针10

4.2 什么是重量级锁

在Java1.6之前synchronized的实现只能通过重量级锁实现，在1.6之后当轻量级锁自旋一定次数后还是没有获取到锁，此时锁就会升级为重量级锁。

重量级锁在竞争锁的时候，除了持有锁的线程，其它竞争锁的线程都会在等待队列中，防止不必要的开销。

4.3 对象头数据

public class SynDemo  {
    public static void main(String[] args) throws InterruptedException {
        SynDemo synDemo = new SynDemo();
       Thread t1 = new Thread(() -> {
           synchronized (synDemo){
               System.out.println(ClassLayout.parseInstance(synDemo).toPrintable());
               try {
                   Thread.sleep(2000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       });

        Thread t2 = new Thread(() -> {
            synchronized (synDemo){

                System.out.println(ClassLayout.parseInstance(synDemo).toPrintable());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
    }
}

 OFFSET  SIZE   TYPE DESCRIPTION                VALUE
   0     4      (object header)       3a f2 6f 1c (00111010 11110010 01101111 00011100) 
   4     4      (object header)       00 00 00 00 (00000000 00000000 00000000 00000000) 
   8     4      (object header)       05 c1 00 f8 (00000101 11000001 00000000 11111000)

4.3 重量级锁实现原理

重量级锁是借助Monitor来实现的，在Java虚拟机中Monitor机制是基于C++实现的，每一个Monitor都有一个ObjectMonitor对象。当锁升级为重量级锁的时候Mark word中的指针就指向ObjectMonitor对象地址。通过ObjectMonitor就可以实现互斥访问同步代码。
在这里插入图片描述

ObjectMonitor的部分变量，用于存储锁竞争过程中的一些值。

ObjectMonitor() {
    // 处于wait状态的线程，会被加入到_WaitSet
    ObjectWaiter * volatile _WaitSet;
    //处于等待锁block状态的线程，会被加入到该列表
    ObjectWaiter * volatile _EntryList;
    // 指向持有ObjectMonitor对象的线程
    void* volatile _owner;
    // _header是一个markOop类型，markOop就是对象头中的Mark Word
    volatile markOop _header;
    // 抢占该锁的线程数，约等于WaitSet.size + EntryList.size
    volatile intptr_t _count;
    // 等待线程数
  	volatile intptr_t _waiters;
    // 锁的重入次数
    volatile intptr_ _recursions;
    // 监视器锁寄生的对象，锁是寄托存储于对象中
    void* volatile  _object;
    // 操作WaitSet链表的锁
    volatile int _WaitSetLock;
    // 嵌套加锁次数，最外层锁的_recursions属性为0
    volatile intptr_t  _recursions;
    // 多线程竞争锁进入时的单向链表
    ObjectWaiter * volatile _cxq;
  }

objectMoniotr源码解析和重量级锁底层实现原理参考：Java多线程：objectMonitor源码解析（4）

4.4 重量级锁加锁释放锁过程

当线程获取Monitor锁时，首先线程会被加入到_EntryList队列当中，当某个线程获取到对象的monitor锁后将ObjectMonitor中的_owner变量设置为当前线程，同时ObjectMonitor中的计数器_count加1即获得锁对象。

若持有monitor的线程调用wait()方法，将释放当前持有的monitor，_owner变量恢复为null，_count自减1，同时该线程进入_WaitSet集合中等待被唤醒。若当前线程执行执行完毕也将释放monitor，以便其它线程线程进入获取monitor。

1.没有线程来竞争锁的时候，ObjectMonitor的_owner是null。

在这里插入图片描述

2.现在有三个线程来获取对象锁，线程首先被封装成ObjectWait对象，然后进入到_EntryList队列中，竞争对象锁。

在这里插入图片描述

3.当t1获取到对象锁的时候，ObjectMonitor对象的_owner指向t1，_count数量加1。

在这里插入图片描述

4.执行完毕之后释放锁，然后又进行下一轮锁竞争。

在这里插入图片描述

🍓四、锁优化

1. 适应性自旋锁

在轻量级锁中，当线程竞争不到锁的时候，是通过CAS自旋一直去获取尝试获取锁，这样就不用放弃CPU的执行时间片

这一过程有一个缺点就是如果持有锁的线程运行的时间很长的话，那么自旋的线程一直占用CPU又不能执行就很浪费资源，可以通过JVM参数设置自旋的次数，如果超过这个次数还没有获取到锁就升级为重量级锁，挂起当前线程。

// 设置自旋次数上限
-XX:PreBlockSpin=10

为了优化自旋占用CPU执行时间片，JVM引入了适应性自旋，适应性自旋会根据前面获取锁的线程自旋的次数来自动调整。

如果前面的线程通过自选获取到了锁，那么JVM会自动增加自旋上限次数。

如果前面的线程自旋很少能获取到锁，那么就会挂起当前线程，升级为重量级锁。

2. 锁消除

2.1 什么是锁消除

Java代码在编译的时候，消除不可能存在共享资源竞争的锁，通过这种方式消除没必要的锁，减少无意义的请求锁时间。

锁消除的依据JIT编译的时候进行逃逸分析，如果当前对象作用域只在方法的内部，那么JVM就认为这个锁可以消除。

// 关闭锁消除
-XX:-EliminateLocks
// 开启逃逸分析
-XX:+DoEscapeAnalysis
// 开启锁消除
-XX:+EliminateLocks

2.2 代码示例

虽然Demo类的synMethod是一个同步方法，但是demo类是一个局部变量，根据逃逸分析该对象只会在栈上分配
属于线程私有的，所以会自动消除锁。

public class Demo {
  public static void main(String[] args) {
    Demo demo = new Demo();
    demo.synMethod();
  }
  private synchronized void synMethod() {
    System.out.println("同步方法");
  }
}

3. 锁粗化

3.1 什么是锁粗化

锁粗化就是把锁的范围加大到整个同步代码的外部，这样能降低频繁的获取锁，从而提升性能。

如下面这段代码，在循环体内加锁，可以把锁加到循环体的外部，这样减少了加锁的次数，提升了性能

3.2 代码示例

for(int i = 0; i < 10; i++){
    synchronized(lock){
    }
}
synchronized(lock) {
  for (int i = 0; i < 10; i++) {
    
  }
}

参考资料

https://juejin.cn/post/7232524757526429756

锁升级图示

前后相随
关注
  • 32
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
运用于Java中的线程----之三（线程间数据共享：synchronized关键字）
qiangzhogshou的博客
08-24 213
并发执行： 1、线程中并发指一个时间段中多个线程都处于已启动但没有运行结束的状态。 2、多个线程之间默认并发运行，这种运行方式往往会出现交叉的情况。 //交叉执行 public class Test { public static void main(String[] args) { new CounterThread("线程1").start(); new CounterThread...
深入理解 Java 中的 synchronized 代码块
weixin_74268571的博客
06-15 751
synchronized的工作原理和使用场景，synchronized的最佳实现方式与场景应用，synchronized代码块减小锁粒度，死循环问题，锁对象问题，死锁问题的讲解
【多线程与高并发】- synchronized锁的认知
热门推荐
qq_43843951的博客
02-19 22万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
Java synchronized关键字实现线程同步
WYSCODER的博客
04-02 6188
synchronized关键字实现线程同步
java多线程-Synchronized关键字详解
lijianbiao0的博客
05-30 691
Synchronized关键字开篇定义作用应用场景原理具体使用使用方式特别注意其他控制并发 / 线程同步方式Lock、ReentrantLock简介区别Compare And Swap（CAS）定义：原理优点典型应用：AtomicInteger 开篇 在Java中，有一个常被忽略 但 非常重要的关键字Synchronized 今天，我将详细讲解 Java关键字Synchronized的所有知识，希...
Java一分钟：线程同步：synchronized关键字
zevjay的博客
05-11 316
关键字用于控制多线程对共享资源的访问，保证同一时间只有一个线程执行特定代码块。同步方法：将修饰符放在方法声明前，使整个方法成为同步的。同步代码块，锁定当前对象，或锁定类的Class对象。
Java多线程-2（线程同步synchronized关键字）
qq_30507459的博客
04-24 547
为何要实现线程同步 多线程机制的目的是为了能并发执行程序，为何要实现线程间同步，使其看起来像是让每个线程按顺序执行呢？答案是：当线程之间没有“相交点”（共享资源）时，不需要线程同步，但是当操作某个线程间共享资源（如静态变量），就需要实现线程同步。 java提供的线程同步机制 一.synchronized关键字 1.当synchronized关键字修饰方法 a.大部分人熟悉的线程同步方式是上锁，...
Java 多线程 --- 线程同步 内部锁synchronized
HelloWorld
08-07 751
synchronized 关键字 synchronized 关键字修饰静态方法 synchronized代码块 --- synchronized blocks synchronized 保证原子性, 可见性, 有序性
多线程学习笔记(四)--synchronized同步关键字
至尊宝
05-02 2万+
强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan 1.前言 当多个线程同时访问某一个共享资源时,可能会出现执行结果与期待结果不一致的情况,这时候就是"非线程安全"的。解决"非线程安全"可以采用synchronized关键字锁类或锁对象,本文大部分实例来自于《Java多线程编程核心技术》 2.访问对象中实例变量造成"非线程安全" ...
Java基础进阶多线程-线程安全和synchronized关键字
qq_46096136的博客
09-11 8086
线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全。当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在。doOther方法执行的时候需要等待doSome方法的结束吗？doOther方法执行的时候需要等待doSome方法的结束吗？synchronized后面小括号中传的这个“数据”是相当关键的。doOther方法执行的时候需要等待doSome方法的结束吗？doOther方法执行的时候需要等待doSome方法的结束吗？而服务器已经将线程的定义，线程对象的创建，线程。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 817
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 884
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1016
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 824
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【JAVA】相关程序组件
qq_44077764的博客
07-15 151
【JAVA】相关程序组件
【Java算法】前缀和 下
最新发布
2302_79806056的博客
07-18 681
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 509
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 700
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
Java多线程解析：synchronized关键字与线程同步
"关键代码段synchronized-JavaThread" 在Java编程中，`synchronized`关键字是用于实现线程同步的关键工具，...理解并熟练应用`synchronized`关键字以及掌握Java多线程的原理和实践是编写高效、安全的并发程序的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值