并发之Synchronized说明

于 2022-06-26 14:33:08 发布
阅读量234 收藏
点赞数 2
分类专栏： 学习笔记 文章标签： jvm java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ABestRookie/article/details/125469703
版权

并发之Synchronized说明

1 Monitor概述

Java对象头

以32位虚拟机为例:

普通对象

在这里插入图片描述

数组对象

在这里插入图片描述

其中Mark Word结构

在这里插入图片描述

一般组成为:

25位 hashcode + 分代年龄(经过几次回收仍存在再移至老年代) + 是否启用偏向锁(0否 1是)+加锁标识信息

锁标识:

01 没锁

00 轻量级锁

10 重量级锁

2 Monitor锁

Monitor, 又称监视器或管程.每个Java对象都可以关联一个Monitor对象,如果Synchronized给对象上锁(重量级)之后, 该对象头的Mark Word中设置就指向Monitor对象的指针

在这里插入图片描述

说明:

  • 刚开始Monitor中的Owner为null
  • 当线程2执行synchronized(obj)就会将Monitor的所有者Owner置为线程2, Monitor中只能有一个Owner
  • 线程2上锁的过程中, 如果线程3,线程4,线程5也来执行synchronized(obj),就会进入EntryList Blocked
  • 线程2执行完同步代码块内容,会唤醒EntryList中等待的线程来竞争锁, 竞争的是非公平的(内置了策略,不是随机的)

synchronized必须是进入同一对象的monitor才有效果

不加synchronized对象不会管理监视器,不遵从该规则

3 Synchronized进阶

1 轻量级锁

使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以 使用轻量级锁来优化。

轻量级锁对使用者是透明的，即语法仍然是 synchronized

static final Object obj = new Object();
public static void method1() {
 synchronized( obj ) {
 // 同步块 A
 method2();
 }
}
public static void method2() {
 synchronized( obj ) {
 // 同步块 B
 }
}

说明:

  • 1 创建锁记录（Lock Record）对象，每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的 Mark Word

在这里插入图片描述

  • 2 让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存 入锁记录

在这里插入图片描述

  • 3 如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下

在这里插入图片描述

  • 4 如果 cas 失败，有两种情况
    • 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
    • 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数

在这里插入图片描述

  • 5 当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重 入计数减一

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ekWWkzV4-1656224885218)(assets/image-20220626092449488.png)]

  • 6 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象 头
    • 成功，则解锁成功
    • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

2 锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有 竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

static Object obj = new Object();
public static void method1() {
 synchronized( obj ) {
 // 同步块
 }
}

  • 1 当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁
    在这里插入图片描述

  • 2 这时 Thread-1 加轻量级锁失败，进入锁膨胀流程

    • 即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址
    • 然后自己进入 Monitor 的 EntryList BLOCKED

在这里插入图片描述

  • 3 当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁 流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程.

3 自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步 块，释放了锁），这时当前线程就可以避免阻塞.

成功情况

在这里插入图片描述

失败情况

在这里插入图片描述

说明:

  • 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势
  • 在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会 高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能
  • Java 7 之后不能控制是否开启自旋功能, 即底层自己实现

4 偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。

Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现 这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有

static final Object obj = new Object();
public static void m1() {
 synchronized( obj ) {
 // 同步块 A
 m2();
 }
}
public static void m2() {
 synchronized( obj ) {
 // 同步块 B
 m3();
 }
}
public static void m3() {
 synchronized( obj ) {
     // 同步块 C
 }
}

在这里插入图片描述

在这里插入图片描述

偏向状态

64位对象头格式

在这里插入图片描述

一个对象创建时:

  • 如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的 thread、epoch、age 都为 0
  • 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数 - XX:BiasedLockingStartupDelay=0 来禁用延迟
  • 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、 age 都为 0，第一次用到 hashcode 时才会赋值
1 测试延迟性
class Dog {}

利用第三方工具jol查看请求头信息

// 添加虚拟机参数 -XX:BiasedLockingStartupDelay=0 
public static void main(String[] args) throws IOException {
 Dog d = new Dog();
 ClassLayout classLayout = ClassLayout.parseInstance(d);
 new Thread(() -> {
 log.debug("synchronized 前");
 System.out.println(classLayout.toPrintableSimple(true));
 synchronized (d) {
 log.debug("synchronized 中");
 System.out.println(classLayout.toPrintableSimple(true));
 }
 log.debug("synchronized 后");
 System.out.println(classLayout.toPrintableSimple(true));
 }, "t1").start();
}
/*
运行结果:
11:08:58.117 c.TestBiased [t1] - synchronized 前
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 
11:08:58.121 c.TestBiased [t1] - synchronized 中
00000000 00000000 00000000 00000000 00011111 11101011 11010000 00000101 
11:08:58.121 c.TestBiased [t1] - synchronized 后
00000000 00000000 00000000 00000000 00011111 11101011 11010000 00000101 

*/

处于偏向锁的对象解锁后，线程 id 仍存储于对象头中

测试禁用

在上面测试代码运行时在添加 VM 参数 -XX:-UseBiasedLocking 禁用偏向锁

/*
运行结果:
11:13:10.018 c.TestBiased [t1] - synchronized 前
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
11:13:10.021 c.TestBiased [t1] - synchronized 中
00000000 00000000 00000000 00000000 00100000 00010100 11110011 10001000 
11:13:10.021 c.TestBiased [t1] - synchronized 后
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 
*/

测试hashCode

  • 正常状态对象一开始是没有 hashCode 的，第一次调用才生成
2 撤销
1 调用对象hashCode

调用对象hashCode, 但偏向锁的对象 MarkWord 中存储的是线程 id，如果调用 hashCode 会导致偏向锁被 撤销

  • 轻量级锁会在锁记录中记录 hashCode
  • 重量级锁会在 Monitor 中记录 hashCode

在调用 hashCode 后使用偏向锁，记得去掉 -XX:-UseBiasedLocking

/*
11:22:10.386 c.TestBiased [main] - 调用 hashCode:1778535015 
11:22:10.391 c.TestBiased [t1] - synchronized 前
00000000 00000000 00000000 01101010 00000010 01001010 01100111 00000001 
11:22:10.393 c.TestBiased [t1] - synchronized 中
00000000 00000000 00000000 00000000 00100000 11000011 11110011 01101000 
11:22:10.393 c.TestBiased [t1] - synchronized 后
00000000 00000000 00000000 01101010 00000010 01001010 01100111 00000001 
*/
2 其它线程使用对象

当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁

private static void test2() throws InterruptedException {
 Dog d = new Dog();
 Thread t1 = new Thread(() -> {
 synchronized (d) {
 log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 synchronized (TestBiased.class) {
 TestBiased.class.notify();
 }
 // 如果不用 wait/notify 使用 join 必须打开下面的注释
 // 因为：t1 线程不能结束，否则底层线程可能被 jvm 重用作为 t2 线程，底层线程 id 是一样的
 /*try {
 System.in.read();
 } catch (IOException e) {
 e.printStackTrace();
 }*/
 }, "t1");
 t1.start();
 Thread t2 = new Thread(() -> {
 synchronized (TestBiased.class) {
 try {
 TestBiased.class.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
 synchronized (d) {
 log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
 }, "t2");
 t2.start();
}
/*
[t1] - 00000000 00000000 00000000 00000000 00011111 01000001 00010000 00000101 
[t2] - 00000000 00000000 00000000 00000000 00011111 01000001 00010000 00000101 
[t2] - 00000000 00000000 00000000 00000000 00011111 10110101 11110000 01000000 
[t2] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 

*/
3 调用wait/notify
public static void main(String[] args) throws InterruptedException {
 Dog d = new Dog();
 Thread t1 = new Thread(() -> {
 log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
 synchronized (d) {
 log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
 try {
 d.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 }, "t1");
 t1.start();
 new Thread(() -> {
 try {
 Thread.sleep(6000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 synchronized (d) {
 log.debug("notify");
 d.notify();
 }
 }, "t2").start();
}
/*
[t1] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 
[t1] - 00000000 00000000 00000000 00000000 00011111 10110011 11111000 00000101 
[t2] - notify 
[t1] - 00000000 00000000 00000000 00000000 00011100 11010100 00001101 11001010 

*/
3 批量重偏向

  • 如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象 的 Thread ID

  • 当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至 加锁线程

private static void test3() throws InterruptedException {
 Vector<Dog> list = new Vector<>();
 Thread t1 = new Thread(() -> {
 for (int i = 0; i < 30; i++) {
 Dog d = new Dog();
 list.add(d);
 synchronized (d) {
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 }
 synchronized (list) {
 list.notify();
 } 
 }, "t1");
 t1.start();
 
 Thread t2 = new Thread(() -> {
 synchronized (list) {
 try {
 list.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 log.debug("===============> ");
 for (int i = 0; i < 30; i++) {
 Dog d = list.get(i);
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 synchronized (d) {
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 }, "t2");
 t2.start();
}
4 批量撤销

当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至 加锁线程

static Thread t1,t2,t3;
private static void test4() throws InterruptedException {
 Vector<Dog> list = new Vector<>();
 int loopNumber = 39;
 t1 = new Thread(() -> {
 for (int i = 0; i < loopNumber; i++) {
 Dog d = new Dog();
 list.add(d);
 synchronized (d) {
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 }
 LockSupport.unpark(t2);
 }, "t1");
 t1.start();
 t2 = new Thread(() -> {
 LockSupport.park();
 log.debug("===============> ");
 for (int i = 0; i < loopNumber; i++) {
 Dog d = list.get(i);
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 synchronized (d) {
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 LockSupport.unpark(t3);
 }, "t2");
 t2.start();
 t3 = new Thread(() -> {
 LockSupport.park();
 log.debug("===============> ");
 for (int i = 0; i < loopNumber; i++) {
 Dog d = list.get(i);
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 synchronized (d) {
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
 }
 }, "t3");
 t3.start();
 t3.join();
 log.debug(ClassLayout.parseInstance(new Dog()).toPrintableSimple(true));
}

5 锁消除

案例

@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations=3)
@Measurement(iterations=5)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark {
 static int x = 0;
 @Benchmark
 public void a() throws Exception {
 x++;
 }
 @Benchmark
 public void b() throws Exception {
 Object o = new Object();
 synchronized (o) {
 x++;
      }
 }
}

使用命令执行jar包: java -jar benchmarks.jar

Benchmark Mode Samples Score Score error Units 
c.i.MyBenchmark.a avgt 5 1.542 0.056 ns/op 
c.i.MyBenchmark.b avgt 5 1.518 0.091 ns/op

两个方法执行时间相差不大, 因为b方法内虽然添加锁, 但是每个锁对象不一致,故系统判断锁无效,即实际没有加锁效果.

禁用锁消除

执行命令: java -XX:-EliminateLocks -jar benchmarks.jar

Benchmark Mode Samples Score Score error Units 
c.i.MyBenchmark.a avgt 5 1.507 0.108 ns/op 
c.i.MyBenchmark.b avgt 5 16.976 1.572 ns/op

b方法使用时间明显较长.

锁粗化

对相同对象多次加锁，导致线程发生多次重入，可以使用锁粗化方式来优化，这不同于之前讲的细分锁的粒度。

韩_师兄
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第09讲：Java 线程优化 偏向锁，轻量级锁、重量级锁
ChinaDragon10的博客
07-21 522
Java 线程优化 偏向锁，轻量级锁、重量级锁
并发系列三：证明分代年龄、无锁、偏向锁、轻量锁、重(chong)偏向、重(chong)轻量、重量锁
avengerEug的博客
05-31 857
前言 [上篇文章]咱们了解了synchronized关键字的常见用法、对象头以及证明了一个对象在无锁状态下的对象头markwork部分的前56位存储的是hashcode。接下来，咱们继续来根据对象头分别证明分代年龄为什么是15、无锁、偏向锁、轻量锁、重(chong)偏向、重(chong)轻量、重量锁，这些锁是真实存在的，咱们可以通过代码来重现。废话不多说，咱们一一来证明 一、证明分代年龄为什么为15 大家都知道，在jvm中，若一个对象在survivor区经过了15次的young gc。当再进行一次yo
synchronized优化原理--重量级锁、轻量级锁、偏向锁
weixin_42048754的博客
08-09 117
synchronized原理及重量级锁 采用【互斥】的方式让同一时刻至多只有一个线程能够持有对象锁，其他线程想获取这个对象锁就会阻塞住，从而保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换 语法： synchronized(锁对象) { 临界区代码 } synchronized放在成员方法上，等价于锁住this对象； synchronized放在静态方法上，等价于锁住类； 1、对象头： 对象头包括：Mark Word 和 Klass Word。 Kclass Word 32位：指向
synchronized中的偏向锁、轻量级锁、重量级锁
BushRo
03-11 1240
对于synchronized这个关键字，可能之前大家有听过，他是一个重量级锁，开销很大，建议大家少用点。但到了jdk1.6之后，该关键字被进行了很多的优化，，建议大家多使用。 在现在的版本中，锁的状态总共有四种： 无锁状态 偏向锁 轻量级锁 重量级锁 锁的“重量”从左到右，依次递增 锁实际上是加在对象上的，那么被加了锁的对象我们称之为锁对象，在java中，任何一个对象都能成为锁对象。 为了让大家更好着理解虚拟机是如何知道这个对象就是一个锁对象的，我们下面简单介绍一下java中一个对象的结构 java对象
偏向锁撤销
搓搓那年时光静好
06-14 1976
撤销-其他线程使用对象 当有其他线程使用偏向锁对象时，会将偏向锁升级为轻量级锁 private static void test2() throws InterruptedException { Dog d = new Dog(); Thread t1 = new Thread(() -> { synchronized (d) { log.debug(ClassLayout.parseInstance(d).toPrintableSimpl
Java 并发编程学习笔记之Synchronized底层优化
09-02
Java并发编程中的Synchronized是Java实现线程同步的关键机制，其在JDK1.6之后进行了大量的优化，包括引入了轻量级锁和偏向锁，以提升并发性能。以下是关于这些优化的详细解释： **一、重量级锁** 重量级锁是基于...
Java并发编程：Synchronized及其实现原理
12-22
　Synchronized是Java中解决并发问题的一种常用的方法，也是简单的一种方法。Synchronized的作用主要有三个：（1）确保线程互斥的访问同步代码（2）保证共享变量的修改能够及时可见（3）有效解决重排序问题。从语法...
Synchronized 终极说明教程
07-19
《Synchronized 终极说明教程》 在Java编程语言中，多线程是并发执行任务的重要方式，而`synchronized`关键字则是确保线程安全、防止数据竞争的关键工具。本教程将深入探讨`synchronized`的各个方面，包括其用法、...
Java并发底层实现原理学习心得
08-28
本文将深入探讨Java并发底层实现的两个关键关键字：volatile和synchronized。 首先，我们来看volatile关键字。volatile保证了多线程环境下的可见性和有序性，但不保证原子性。当一个变量被volatile修饰时，它的修改...
Java并发编程-synchronized锁优化
Java硬件工程师的博客
02-05 4013
1.小故事 synchronized工作方式是让每个对象关联一个monitor，monitor锁是由操作系统提供的，要使用它成本较高，如果是每次进入synchronized的话需要获得一个monitor锁，那么就需要很大的开销。从Java6开始对synchronized获取锁的方式进行了优化。除了可以使用轻量级锁，还可以使用偏向级锁来进行优化。 故事角色 老王 - JVM 小南 - 线程 小女 - 线程 房间 - 对象 房间门上 - 防盗锁 - Monitor 房间门上 - 小南书包
并发编程学习第二章
weixin_45976114的博客
03-20 229
并发编程2二.并发编程进阶1.共享模型之管程1.1.共享带来的问题1.2.临界区 Critical Section1.3.竞态条件 Race Condition1.4.synchronized 解决方案1.5.面向对象改进1.6.方法上的 synchronized1.7.所谓的“线程八锁”1.7.1.情况11.7.2.情况21.7.3. 情况31.7.4.情况41.7.5.情况51.7.6.情况61.7.7.情况71.7.8.情况81.8.变量的线程安全分析 二.并发编程进阶 1.共享模型之管程 1.1.共
Java并发编程之美02
fechinchu的博客
04-06 644
Java并发编程之美021.共享模型之管程1.1.synchronized1.2方法上的synchronized1.3.变量的线程安全1.3.1.局部变量的线程安全分析1.3.2成员变量的线程安全分析1.3.3.局部变量有可能出现的线程安全问题1.4.常见线程安全类1.4.1.线程安全类方法的组合1.4.2.不可变类线程安全性1.5.Monitor1.5.1.Java对象头1.5.2.Monito...
Java 多线程共享模型之管程（上）
m0_71682321的博客
06-07 121
Java 多线程共享模型之管程
【JAVA并发编程-黑马】第三章
qq_37023928的博客
06-07 962
一、synchronized 原理(字节码角度) static final Object lock = new Object(); static int counter = 0; public static void main(String[] args) { synchronized (lock) { counter++; } }
关于easyExcel中读取Excel表头的说明
热门推荐
ABestRookie的博客
04-12 1万+
关于easyExcel中读取Excel表头的说明1 环境准备2 单表头Excel3 多表头Excel4 总结 在使用easyExcel读取文件时,对于Excel的表头,在解析读取时分成不同的状态,需要加以区分. 1 环境准备 准备一个可以正常访问的SpringBoot项目. 1 添加pom <!-- https://mvnrepository.com/artifact/com.alibaba/easyexcel --> <dependency>
Oracle的分页查询
ABestRookie的博客
04-10 1万+
Oracle的分页查询1 分页查询引入2 Oracle分页查询 1 分页查询引入 关于查询功能, 一次将所有查询结果返回给前台,带来的问题有: 1是查询量较大,查询时间多 2是前台的数据展示能力有限. 所以一般采用分页查询功能. Mysql数据库: 使用Limit (page, size)关键字做分页查询. Oracle数据库: 因为Oracle中没有Limit关键字,所以使用rownum伪列做分页. 2 Oracle分页查询 方法一: select a.* from ( select t.*,ro
关于@SneakyThrows使用
ABestRookie的博客
10-16 6858
关于@SneakyThrows使用1 异常引入2 @SneakyThrows1 SneakyThrows注解的源码2使用案例 关于@SneakyThrows注解的使用,主要是消除代码中异常处理代码. 1 异常引入 Java中异常Throwable分为两类, 一种是Exception类,称为受检异常(Checked Exception), 第二种是RuntimeException类, 运行时异常. Exception类异常,强制要求方法抛出可能出现的异常,调用者必须处理这个异常. 一般在代码中,程序员通过
EasyPoi 导入校验使用
ABestRookie的博客
01-31 4202
EasyPoi 导入校验使用 因工作需要,使用easypoi导入表格,并进行校验,将表格中有问题的地方,给出提示信息,以表格形式返回. 本篇,直接讲述Excel导入校验,基本介绍后续补上. 1 基于Springboot的easypoi导入表格校验 1 pom.xml <!--easypoi与SpringBoot的整合包--> <dependency> <groupId>cn.afterturn</group
java synchronized修饰实例方法的作用，举例说明
最新发布
06-03
在这个示例中，increment()、decrement()和getCount()方法都被synchronized修饰，因此同一时刻只有一个线程能够访问这些方法，保证了对count变量的同步控制，避免了多线程并发访问时的数据竞争问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值