Java 多线程 Synchronized修饰对象

已于 2022-09-30 11:32:50 修改
阅读量345 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： java 多线程 thread 并发编程
于 2022-09-28 16:52:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skye111321/article/details/127092635
本文通过多个实验场景，探讨了Java中Synchronized关键字的工作原理。包括同一对象锁的竞争、不同对象锁的同时访问等，并分析了锁的获取与释放过程。

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

介绍

读书时很少做一些要求较高的多线程项目，导致自身对于锁的认识处于非常浅显的程度。在进入职场后也只是简单的给方法加Synchronized关键字，但是随着项目的完善度越来越高，简单的锁住一个方法已经无法满足复杂的业务需求。这次也并非学习特别厉害的技术，只是深度了解一下Synchronized关键字是如何工作的，尤其是锁住一个对象时

准备

Demo中主要是使用List of String模拟想要锁住的对象，Main方法中用Executors模拟多线程

测试

两个线程尝试进入同一个锁

代码

public static void main(String[] args) {
    Demo demo = new Demo();
    demo.init();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(demo::block1);
    executorService.execute(demo::block1);
}

public void block1() {
    log.info("Thread {} Enter block 1", Thread.currentThread().getId());
    String robot = robotList.stream().filter(robotName -> robotName.equalsIgnoreCase("robot-01")).findAny().get();
    synchronized (robot) {
        log.info("Thread {} Enter synchronized 1", Thread.currentThread().getId());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("Thread {} Leave synchronized 1", Thread.currentThread().getId());
    }
    log.info("Thread {} Leave block 1", Thread.currentThread().getId());
}

结果

16:29:52.055 Thread 24 Enter block 1
16:29:52.055 Thread 25 Enter block 1
16:29:52.058 Thread 25 Enter synchronized 1
16:30:02.059 Thread 25 Leave synchronized 1
16:30:02.060 Thread 25 Leave block 1
16:30:02.060 Thread 24 Enter synchronized 1
16:30:12.072 Thread 24 Leave synchronized 1
16:30:12.072 Thread 24 Leave block 1

结论

当两个线程尝试进入同步代码块，线程25先获取到锁，线程24只能等待

两个线程尝试进入不同的方法，但是同一个同步代码块

代码

public static void main(String[] args) {
    Demo demo = new Demo();
    demo.init();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(demo::block1);
    executorService.execute(demo::block2);
}


public void block1() {
    log.info("Thread {} Enter block 1", Thread.currentThread().getId());
    String robot = robotList.stream().filter(robotName -> robotName.equalsIgnoreCase("robot-01")).findAny().get();
    synchronized (robot) {
        log.info("Thread {} Enter synchronized 1", Thread.currentThread().getId());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("Thread {} Leave synchronized 1", Thread.currentThread().getId());
    }
    log.info("Thread {} Leave block 1", Thread.currentThread().getId());
}

public void block2() {
    log.info("Thread {} Enter block 2", Thread.currentThread().getId());
    String robot = robotList.stream().filter(robotName -> robotName.equalsIgnoreCase("robot-01")).findAny().get();
    synchronized (robot) {
        log.info("Thread {} Enter synchronized 2", Thread.currentThread().getId());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("Thread {} Leave synchronized 2", Thread.currentThread().getId());
    }
    log.info("Thread {} Leave block 2", Thread.currentThread().getId());
}

结果

16:33:19.451 [pool-1-thread-2] INFO com.skye.Synchronized.OneObjectSynchronizedTwoMehtod.Demo - Thread 25 Enter block 2
16:33:19.451 [pool-1-thread-1] INFO com.skye.Synchronized.OneObjectSynchronizedTwoMehtod.Demo - Thread 24 Enter block 1
16:33:19.454 Thread 25 Enter synchronized 2
16:33:29.457 Thread 25 Leave synchronized 2
16:33:29.457 Thread 25 Leave block 2
16:33:29.457 Thread 24 Enter synchronized 1
16:33:39.461 Thread 24 Leave synchronized 1
16:33:39.461 Thread 24 Leave block 1

结论

虽然两个线程进入不同的方法，但是由于锁住的对象一样，线程24依然需要等待线程25释放锁

获得锁的线程在释放锁之前进入另一个方法中的同步代码块

代码

public void block1() {
    log.info("Thread {} Enter block 1", Thread.currentThread().getId());
    String robot = robotList.stream().filter(robotName -> robotName.equalsIgnoreCase("robot-01")).findAny().get();
    synchronized (robot) {
        log.info("Thread {} Enter synchronized 1", Thread.currentThread().getId());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        block2();
        log.info("Thread {} Leave synchronized 1", Thread.currentThread().getId());
    }
    log.info("Thread {} Leave block 1", Thread.currentThread().getId());
}

结果

16:36:46.761 Thread 24 Enter block 1
16:36:46.764 Thread 24 Enter synchronized 1
16:36:47.772 Thread 25 Enter block 2
16:36:56.772 Thread 24 Enter block 2
16:36:56.772 Thread 24 Enter synchronized 2
16:37:06.775 Thread 24 Leave synchronized 2
16:37:06.775 Thread 24 Leave block 2
16:37:06.775 Thread 24 Leave synchronized 1
16:37:06.776 Thread 24 Leave block 1
16:37:06.776 Thread 25 Enter synchronized 2
16:37:16.778 Thread 25 Leave synchronized 2
16:37:16.778 Thread 25 Leave block 2

结论

因为线程24已经获得锁，所以即使线程24在线程25之后进入Block 2，也能先执行

两个线程进入同一个方法，但是不同的对象

代码

public static void main(String[] args) {
    Demo demo = new Demo();
    demo.init();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> {
        String robotCode = "robot-01";
        demo.block1(robotCode);
    });
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    executorService.execute(() -> {
        String robotCode = "robot-02";
        demo.block1(robotCode);
    });
}

public void block1(String robotCode) {
    log.info("Thread {} Enter block 1", Thread.currentThread().getId());
    String robot = robotList.stream().filter(robotName -> robotName.equalsIgnoreCase(robotCode)).findAny().get();
    synchronized (robot) {
        log.info("Thread {} Enter synchronized 1", Thread.currentThread().getId());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        block2(robotCode);
        log.info("Thread {} Leave synchronized 1", Thread.currentThread().getId());
    }
    log.info("Thread {} Leave block 1", Thread.currentThread().getId());
}

public void block2(String robotCode) {
    log.info("Thread {} Enter block 2", Thread.currentThread().getId());
    String robot = robotList.stream().filter(robotName -> robotName.equalsIgnoreCase(robotCode)).findAny().get();
    synchronized (robot) {
        log.info("Thread {} Enter synchronized 2", Thread.currentThread().getId());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("Thread {} Leave synchronized 2", Thread.currentThread().getId());
    }
    log.info("Thread {} Leave block 2", Thread.currentThread().getId());
}

结果

16:42:30.608 Thread 24 Enter block 1
16:42:30.611 Thread 24 Enter synchronized 1
16:42:31.616 Thread 25 Enter block 1
16:42:31.616 Thread 25 Enter synchronized 1
16:42:40.619 Thread 24 Enter block 2
16:42:40.619 Thread 24 Enter synchronized 2
16:42:41.619 Thread 25 Enter block 2
16:42:41.619 Thread 25 Enter synchronized 2
16:42:50.631 Thread 24 Leave synchronized 2
16:42:50.631 Thread 24 Leave block 2
16:42:50.631 Thread 24 Leave synchronized 1
16:42:50.631 Thread 24 Leave block 1
16:42:51.629 Thread 25 Leave synchronized 2
16:42:51.629 Thread 25 Leave block 2
16:42:51.629 Thread 25 Leave synchronized 1
16:42:51.629 Thread 25 Leave block 1

结论

因为两个线程进入不同的对象的锁，所以无需等待

结束语

同样是Synchronized关键字，用法不同实现的效果也不同。以前只会修饰方法，只适用于部分场景。如今可以稍微灵活一点使用该关键字

Java 多线程synchronized关键字详解(六)
09-03
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。在这个问题中，我们将深入理解`synchronized`的关键字用法，包括同步方法和同步块。 1. **...
Java多线程程序中synchronized修饰方法的使用实例
09-02
本篇将深入探讨`synchronized`修饰方法在Java多线程程序中的使用实例。 1. **同步方法** 同步方法是通过在方法声明前加上`synchronized`关键字来实现的。当一个方法被声明为同步时，意味着在同一时刻只有一个线程...
Java中synchronized关键字修饰方法同步的用法详解
09-02
synchronized可以用来同步静态和非静态方法,下面就具体来看一下Java中synchronized关键字修饰方法同步的用法详解:
synchronized关键字（一）修饰对象
weixin_44368081的博客
04-20 1596
synchronized关键字（一）修饰对象 文章目录synchronized关键字（一）修饰对象一、 synchronized是什么？二、修饰对象三、注意事项 参考文献：https://www.jb51.net/article/226912.htm 一、 synchronized是什么？ synchronized是Java中的关键字，是一种同步锁。 二、修饰对象 1.synchronized（this）{} 修饰一个代码块时，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的
synchronized
weixin_34238642的博客
02-11 123
2019独角兽企业重金招聘Python工程师标准>>> ...
synchronized 修饰的方法使用的对象锁
luyongchuan的博客
04-10 787
synchronized 加到 static 方法前面是给class 加锁，即类锁；而synchronized 加到非静态方法前面是给对象上锁。 public class Task2 { public synchronized static void doLongTimeTaskA() { System.out.println("name = " + Thread.cur...
同步 java_JAVA 同步之 synchronized 修饰方法
weixin_28700593的博客
02-12 185
在JAVA多线程编程中，将需要并发执行的代码放在Thread类的run方法里面，然后创建多个Thread类的对象，调用start()方法，线程启动执行。当某段代码需要互斥时，可以用 synchronized 关键字修饰，这里讨论 synchronized 关键字修饰方法时，是如何互斥的。synchronized 修饰方法时锁定的是调用该方法的对象。它并不能使调用该方法的多个对象在执行顺序上互斥。下...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
本文将深入探讨synchronized修饰方法在Java中的使用及其工作原理，并通过实例演示其应用。 1. **synchronized原理** synchronized基于Java的内置锁（也称为对象锁或 monitors）机制。当一个线程进入synchronized...
Java多线程中使用synchronized说明
12-22
在Java多线程编程中，`synchronized`有多种用法，包括修饰实例方法、静态方法以及作为代码块来锁定特定的对象引用。 1. **修饰实例方法**： 当`synchronized`关键字用于实例方法时，它会对该实例对象加锁。这意味...
深入讲解java线程与synchronized关键字
08-31
Java中的多线程同步是通过对象锁机制来实现的，synchronized关键字正是这一机制的关键。它确保了在任何时刻，只有一个线程能够访问特定的共享资源，从而避免数据不一致的问题。本文将详细讲解Java线程的基本概念、...
synchronized关键字修饰对象锁，同步与非同步对该方法的访问及修改
liusarazhang的博客
05-22 676
当synchronized修饰一个方法或者代码时，非同步的方法可以访问和修改synchronized修饰的方法或者代码块中的遍历。 代码：package indi.liusai.test;public class test implements Runnable{public static void main(String[] args) { test test=new test();
synchronized 关键字可修饰 object和方法
wangliwei4321的专栏
02-15 1389
 原文转自： http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一
synchronized在Java中,synchronized在java中的修饰
weixin_39712705的博客
03-11 329
我们说synchronized让一个线程运行时，保证其安全性。那么在其中synchronized都可以进行哪些操作呢？本篇主要讲的是synchronized的修饰用法，能够对普通方法、静态方法、代码块进行操作。下面将分别对这三种修饰情况，带来代码方面的用法展示，一起来看看synchronized的修饰用法吧。1.修饰普通方法publicclassSynTest8implementsRunn...
synchronized同步机制，修饰类和修饰对象的区别
weixin_30654583的博客
09-18 1061
synchronized用法 synchronized修饰的对象有几种： 修饰一个类：其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象； 修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修饰一个静态的方法：其作用的范围是整个方法，作用的对象是这个类的所有对象； 修饰一...
java synchronized修饰方法和修饰方法块
yuliantao的专栏
10-21 386
感觉这篇文章写的不错，转载其他作者的。Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 二、然而，当一个线程访问object的一个
java synchronized 对象_java基础Synchronized关键字之对象锁
weixin_35916239的博客
02-24 77
package threadDemo;public class ThreadDemo03 {public static void main(String[] args) {T t = new T();Thread t1 = new Thread(t);Thread t2 = new Thread(t);t1.start();try {Thread.sleep(50);} catch (Except...
多线程：synchronized 关键字用法（修饰类，方法，静态方法，代码块）
热门推荐
萨达哈鲁的博客
12-19 2万+
多线程：synchronized 关键字用法（修饰类，方法，静态方法，代码块）synchronized用法synchronized修饰的对象有几种： 修饰一个类：其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象； 修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 修饰一个静态的方法：其作用的范围是整个方法，作用的
java 同步方法 跟 同步代码块区别_同步方法和同步代码块的区别是什么？
weixin_36059505的博客
02-16 444
Synchronized关键字可以用来修饰4种不同类型的代码块: 实例方法静态方法实例方法中的代码块静态方法中的代码块同步方法 public synchronized void add(int value){this.count += value;}注意到此处的Synchronized关键字是加在方法声明处，这会告诉JVM，它是一个同步方法。实例同步方法的锁，是加在拥有该方法的对象之上。因此每个实...
Java多线程中 synchronized 修饰符的用法
Kaysen的博客
09-20 1020
修饰代码块 private Object obj = new Object(); public void method1(){ //对代码块加锁，用一个对象作为锁 synchronized (obj){ } } 修饰方法（本质是对 this 对象加锁） public synchronized void method2(){ //对方法加锁，实际上是对this对象加锁 } 对 this 对象加锁 public void method3(){ synchronize
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

skye111321

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值