synchronized锁住的到底是什么

已于 2022-06-06 10:59:27 修改
阅读量1k 收藏 1
点赞数 2
分类专栏： SpringBoot 文章标签： java
于 2022-03-20 11:19:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_49078070/article/details/123608159
版权
本文详细探讨了Java中线程同步的不同方式，包括静态方法锁类、非静态方法锁实例、代码块锁对象与作用域。通过实例展示了synchronized在类、对象和代码块上的应用，以及它们如何影响线程间的交互和执行顺序。

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

文章目录

论证

  • 修饰方法
    静态方法 锁定的是类
    非静态方法 锁定的是实例对象本身

  • 修饰代码块 锁定的是传入的对象

  • 作用域为全局

1.首先创建线程调用类

修饰方法时

public class TestPrint {
    public static void main(String[] args) {
        Print print= new Print();
        new Thread(()->{
            print.fun1();
        },"A").start();
        new Thread(()->{
            print.fun2();
        },"A").start();
    }
}
class Print{
    public void fun1(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1....");
    }
    public void fun2(){
        System.out.println("2....");
    }
}

控制台为
在这里插入图片描述

2.修饰非静态方法 锁住的是实例对象本身

一个对象（资源类实例化）里面如果有多个synchronized方法，某一时刻只要有一个线程去访问其中一个synchronized方法，其他线程都只能在外等待。换句话说，同一时刻，只能有唯一的线程去访问这些synchronized方法，锁的是当前对象的this，被锁定后，其他的线程都不能进入到当前对象的其他synchronized方法。

把两个方法（非静态）加上synchronized修饰 A线程获取到print对象后 B线程只能在外等待

public class TestPrint {
    public static void main(String[] args) {
        Print print= new Print();
        new Thread(()->{
            print.fun1();
        },"A").start();
        new Thread(()->{
            print.fun2();
        },"B").start();
    }
}
class Print{
    public synchronized void fun1(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1....");
    }
    public synchronized void fun2(){
        System.out.println("2....");
    }
}

在这里插入图片描述
把两个方法（非静态）加上synchronized修饰 print对象执行A线程 print1对象执行B线程 无需等待

public class TestPrint {
    public static void main(String[] args) {
        Print print = new Print();
        Print print1 = new Print();
        new Thread(()->{
            print.fun1();
        },"A").start();
        new Thread(()->{
            print1.fun2();
        },"B").start();
    }
}
class Print{
    public synchronized void fun1(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1....");
    }
    public synchronized void fun2(){
        System.out.println("2....");
    }
}

在这里插入图片描述

只对fun1（非静态）加上synchronized修饰 A线程获取到print对象后 B也可以执行fun2 无需等待

public class TestPrint {
    public static void main(String[] args) {
        Print print = new Print();
        new Thread(()->{
            print.fun1();
        },"A").start();
        new Thread(()->{
            print.fun2();
        },"B").start();
    }
}
class Print{
    public synchronized void fun1(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1....");
    }
    public  void fun2(){
        System.out.println("2....");
    }
}

在这里插入图片描述

3.修饰静态方法 锁定的是类（可以说 类是Class的对象）

  对两个方法都修饰 synchronized static   看出print1对象需要等待print对象执行完才能执行

public class TestPrint {
    public static void main(String[] args) {
        Print print = new Print();
        Print print1 = new Print();
        new Thread(()->{
            print.fun1();
        },"A").start();
        new Thread(()->{
            print1.fun2();
        },"A").start();
    }
}
class Print{
    public static synchronized void fun1(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("1....");
    }
    public static synchronized void fun2(){
        System.out.println("2....");
    }
}

在这里插入图片描述

4. 修饰代码块时

创建for循环线程调用 可看出是并行的


public class TestPrint {
    public static void main(String[] args) {
      Print print = new Print();
      for (int i =0;i< 5;i++){
          new Thread(()->{
              print.fun();
          },"A").start();
      }
    }
}
class Print{
    public  void fun(){
        System.out.println("开始....");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结束....");
    }
}

在这里插入图片描述
当我加入this 开始等待了 五个线程只有一个资源（对象） this锁住的调用的对象

public class TestPrint {
    public static void main(String[] args) {
      Print print = new Print();
      for (int i =0;i< 5;i++){
          new Thread(()->{
              print.fun();
          },"A").start();
      }
    }
}
class Print{
    public  void fun(){
        synchronized (this){
            System.out.println("开始....");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("结束....");
            }
    }
}

在这里插入图片描述
当我把new Print()放到循环里面 就变成了每个线程各有一个资源（对象） 结果就是并行

public class TestPrint {
    public static void main(String[] args) {
      for (int i =0;i< 5;i++){
          Print print = new Print();
          new Thread(()->{
              print.fun();
          },"A").start();
      }
    }
}
class Print{
    public  void fun(){
        synchronized (this){
            System.out.println("开始....");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("结束....");
            }
    }
}

在这里插入图片描述
当我synchronized（类.Class）之后 锁着的是当前类 无论多少个对象来访问都需等待

public class TestPrint {
    public static void main(String[] args) {
      for (int i =0;i< 5;i++){
          Print print = new Print();
          new Thread(()->{
              print.fun();
          },"A").start();
      }
    }
}
class Print{
    public  void fun(){
        synchronized (Print.class){
            System.out.println("开始....");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("结束....");
            }
    }
}

在这里插入图片描述
当我用“1”放入（）中 代码也会等待 “1”只有一份

public class TestPrint {
    public static void main(String[] args) {
      Print print = new Print();
      for (int i =0;i< 5;i++){
          new Thread(()->{
              print.fun();
          },"A").start();
      }
    }
}
class Print{
    public  void fun(){
        synchronized ("1"){
            System.out.println("开始....");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("结束....");
            }
    }
}

在这里插入图片描述
当我用num参数放入（）中 让调用者传入num 如果num是同一个地址 线程也会等待

public class TestPrint {
    public static void main(String[] args) {
      Print print = new Print();
      for (int i =0;i< 5;i++){
          Integer num = 1;
          new Thread(()->{
              print.fun(num);
          },"A").start();
      }
    }
}
class Print{
    public void fun(Integer num){
        synchronized (num){
            System.out.println("开始....");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("结束....");
            }
    }
}

在这里插入图片描述
当我用num参数放入（）中 让调用者每次传入new num num地址不同 线程不会等待

public class TestPrint {
    public static void main(String[] args) {
      Print print = new Print();
      for (int i =0;i< 5;i++){
          Integer num = new Integer(1);
          new Thread(()->{
              print.fun(num);
          },"A").start();
      }
    }
}
class Print{
    public void fun(Integer num){
        synchronized (num){
            System.out.println("开始....");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("结束....");
            }
    }
}

在这里插入图片描述

5. synchronized（）修饰代码块时 锁住的作用域

建立person类

在这里插入代码片

@Service
public class Person {
    public void fun1(){
        synchronized ("111"){
            System.out.println("存钱开始");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("存钱结束");
        }
    }
}

建立student类

@Service
public class Student {
    public void fun2(){
    synchronized("111"){
            System.out.println("花钱开始");
            System.out.println("花钱结束");
        }
    }
}

建立测试controller

@RestController
public class ceshi {
    @Autowired
    Person person;
    @Autowired
    Student student;
    @RequestMapping("/xian")
    public void ceeshi(){
        new Thread(()->{
            person.fun1();
        },"A").start();
        new Thread(()->{
            student.fun2();
        },"B").start();
    }
}

当我用postman访问接口 student对象会等待person对象执行完 才执行 由此可得synchronized修饰代码块（）传入参数地址一样 作用域为全局

【Java】synchronized的使用
L_MaFia的博客
05-27 826
文章目录synchronized锁定的资源锁定对象改变锁定对象为字符串常量减小锁的颗粒度脏读问题支持重入重入1重入2synchronized 与 异常处理synchronized的可见性问题原子性操作一道的面试题方式1:方式2:方式3: synchronized锁定的资源 synchronized修饰的是方法或者代码块来实现同步，但其实锁定的资源其实是对象。synchronized修饰于3种方式（静态方法、普通方法、方法块），其锁定的资源有2种（类对象、类的实例）加synchronized关键字之后不一定能
【线程安全】【线程通信】【Java】synchronized锁讲解，锁方法和锁住变量，隐式锁和显式锁Lock，信息同步
m0_46716894的博客
10-29 1067
【线程安全】【线程通信】【Java】synchronized锁讲解，锁方法和锁住变量，隐式锁和显式锁Lock，信息同步
synchronized锁的是什么？
好好玩的博客
03-30 4911
文章目录1.synchronized是什么2.synchronized锁的是什么1、修饰方法（1）两个普通方法都加锁 1.synchronized是什么 synchronized是java里的一个关键字，可以用来给对象和方法或者代码块加锁，当它锁定一个方法或者代码块的时候，同一时刻最多只有一条线程执行这段代码 synchronized修饰的对象： 修饰方法，被修饰的方法被称为同步方法 修饰代码块，被修饰的代码块被称为同步代码块 2.synchronized锁的是什么 未加锁状态下线程执行： // 未加锁
《图解Java中synchronized到底锁了谁？一篇文章彻底讲清楚！》
最新发布
龚小帅的博客
05-10 651
文章进一步介绍了synchronized的三种用法：同步实例方法、同步静态方法和同步代码块，分别适用于不同的场景。随后，深入探讨了synchronized的底层实现原理，包括Java对象头、锁的升级过程、Monitor机制以及字节码层面的实现。此外，文章还总结了synchronized的特性，如可重入性、不可中断性和可见性。
synchronized锁的是什么
一枚野生程序员 —— Tim
03-28 1671
最近发现synchronized锁的是什么？甚至有人认为synchronized锁的是代码？？！这个我觉得还是很有必要通过实际的示例来说明synchronized锁的到底是什么。 根据获取的锁的分类：获取对象锁和获取类锁！ 获取对象锁的两种用法 1、同步代码块(synchronized(this), synchronized(类实例对象))，锁是小括号()中的实例对象。2...
Java并发——Synchronized关键字和锁升级，详细分析偏向锁和轻量级锁的升级
qq_36777191的博客
02-02 323
目录 一、Synchronized使用场景 二、Synchronized实现原理 三、锁的优化 1、锁升级 2、锁粗化 3、锁消除 一、Synchronized使用场景 Synchronized是一个同步关键字，在某些多线程场景下，如果不进行同步会导致数据不安全，而Synchronized关键字就是用于代码同步。什么情况下会数据不安全呢，要满足两个条件：一是数据共享（临界资源），二是多线程同时访问并改变该数据。 例如： public class AccountingSync imple
synchronized到底锁住的是谁？
jushisi的博客
11-25 1925
本文代码仓库：https://github.com/yu-linfeng/BlogRepositories/tree/master/repositories/sync synchronized从语法的维度一共有3个用法： 1、静态方法加上关键字 2、实例方法（也就是普通方法）加上关键字 3、方法中使用同步代码块 前两种方式最为偷懒，第三种方式比前两种性能要好。 synchronized从锁的...
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析 Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前...
Java:synchronized锁住的是代码还是对象
12-22
在Java中，synchronized关键字是用来控制线程同步的，是在多线程的环境下，控制synchronized代码段不被多个线程同时执行。Synchronized既可以对代码块使用，也可以加在整个方法上。 　关键是，不要认为给方法或者...
解析Java编程之Synchronized锁住的对象
08-29
Java synchronized锁住的对象解析 在Java编程中，synchronized关键字是用于同步的关键字，它可以用于锁住一个对象，以实现线程同步。但是，在使用synchronized关键字时，需要了解锁住的到底是哪个对象，否则可能...
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
首先，我们需要理解synchronized锁住的是对象，而不是代码块。例如，当我们使用`synchronized (o)`对一个对象o进行加锁时，实际上是对o这个对象本身进行锁定，而不是对包围的代码块。这个过程通过修改对象的内部状态...
线程——synchronized到底锁的是什么
weixin_48439438的博客
01-20 126
修饰非静态方法：锁的是调用这个方法的对象 可以看到begin()和end()方法使用synchronized关键字，存在两个线程调用同一个对象thing。 执行过程：thing调用begin()，锁thing，begin()完成，释放thing，thing调用end()，锁thing，end()完成，释放thin 结果： 更改后可以看到，因为每个线程都是new的新对象thing，分别调用begin和end锁的对象也就不同了，所以begin不会阻塞end方法 再次修改：将end方法的synchroni
synchronized 锁的到底是什么？
qq_64064246的博客
08-08 862
1-2：一个对象里面如果有多个 synchronized 方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法，其它线程都只能等待。换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法。锁的是当前对象this，被锁定后，其它线程都不能进入到当前对象的其它的synchronized方法3-4：加个普通方法后发现和同步锁无关换成两个对象后，不是同一把锁了，情况立即变化5-6：都换成静态同步方法后，情况又变化。
synchronized 锁住了什么
听风的专栏
08-25 1488
先上结论：　　类方法中，synchronized锁住的是对象this,只有调用同一个对象的方法才需要获取锁。同时，同一个对象中所有加了synchronize的方法只能一次调用一个　　静态方法中，synchronized锁的是整个类对象，类似于(X.class)，该类中所有加了synchronized的静态方法，一次只能调用一个class Sync { public synchronized v
Synchronized 锁的到底是什么对象？
Iced_Sheep的博客
12-14 915
对于普通同步方法，锁的是 当前实例对象 对于静态同步方法，锁的是 当前类的 Class 对象 对于同步方法块，锁的是 Synchronized 括号中的对象
synchronized锁的到底是谁???
2301_80313139的博客
11-04 776
synchronized锁的是谁? 它的用法是怎么样的? 快来一探究竟~~
synchronized锁
qq_61353850的博客
03-19 5642
1、synchronize锁的修饰的是方法和块 2、synchronize锁修饰静态方法就是类锁；修饰非静态方法就是对象锁。 3、类锁：是如果有N个静态的方法被synchronize修饰，有一个线程执行其中一个加锁的静态方法，那么其他的线程就无法继续调用这个类中的其他的加锁的静态方法，直到这个静态方法被执行完，其他加锁静态方法才可以被执行。不加锁的方法是不受影响的。 4、对象锁：在java中，类中定义一个非静态的方法，如果需要在其他类中使用这个方法，我们就要在其他类中，new一个新的对象。对象锁的意义
类锁和对象锁，synchronized修饰static方法与非static方法的区别
weixin_30496751的博客
10-23 210
当synchronized修饰一个static方法时，多线程下，获取的是类锁(即Class本身，注意:不是实例)， 作用范围是整个静态方法，作用的对象是这个类的所有对象。 当synchronized修饰一个非static方法时，多线程下，获取的是对象锁(即类的实例对象)， 作用范围是整个方法，作用对象 是调用该方法的对象 结论...
synchronized 锁住类
07-25
在 Java 中，synchronized 关键字可以用于锁住类，而不仅仅是对象。通过锁住类，可以确保在同一时间内只有一个线程可以访问该类的 synchronized 代码块或 synchronized 方法。 要锁住一个类，可以使用以下两种方式： 1. synchronized 代码块： ``` synchronized (ClassName.class) { // 需要同步的代码 } ``` 这里的 `ClassName` 是需要锁住的类名。当一个线程进入 synchronized 代码块时，它会尝试获取 `ClassName.class` 的锁。只有一个线程能够获取到这个锁，其他线程则会被阻塞，直到获取到锁为止。 2. synchronized 静态方法： ``` public static synchronized void methodName() { // 需要同步的代码 } ``` 在静态方法前加上 synchronized 关键字，表示该方法是类级别的同步方法。当多个线程同时调用这个静态方法时，只有一个线程能够执行其中的代码。 锁住类的方式与锁住对象的方式相似，都是通过获取锁来实现线程同步。不同之处在于，锁住类是针对整个类而言，而锁住对象是针对特定对象实例。 需要注意的是，锁住类的方式可能会导致性能问题，因为它会限制对整个类的并发访问。因此，应该谨慎使用锁住类的方式，只在必要的情况下使用。另外，锁住类的方式不能与锁住对象的方式混用，否则无法实现预期的同步效果。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值