synchronized到底锁的是谁

最新推荐文章于 2024-04-04 19:44:22 发布
原创 最新推荐文章于 2024-04-04 19:44:22 发布 · 202 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文探讨了Java中synchronized在静态方法和非静态方法上的区别，以及对象锁与类锁的实战示例，揭示了如何影响线程并发和资源竞争。

举例：


public class Data {

    public static void main(String[] args) {

        Test test=new Test();

        //线程A
        new Thread(()->{

            test.eat();
        },"A").start();


        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        //线程B
        new Thread(()->{

            test.run();
        },"B").start();

    }
}

class Test {

    public void eat(){
        try{
            TimeUnit.SECONDS.sleep(3);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("============1=eat");
    }


    public void run(){
        System.out.println("============2=run");
    }
}

结果：

============2=run
============1=eat

Process finished with exit code 0

再次修改：

public class Data {

    public static void main(String[] args) {

        Test test=new Test();

        //线程A
        new Thread(()->{

            test.eat();
        },"A").start();


        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        //线程B
        new Thread(()->{

            test.run();
        },"B").start();

    }
}

class Test {

    public synchronized void eat(){
        try{
            TimeUnit.SECONDS.sleep(3);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("============1=eat");
    }


    public synchronized void run(){
        System.out.println("============2=run");
    }
}

输出结果：非静态类：锁定的是方法的调用者

============1=eat
============2=run

Process finished with exit code 0

再次修改：去掉run方法的synchronized 关键字

public class Data {

    public static void main(String[] args) {

        Test test=new Test();

        //线程A
        new Thread(()->{

            test.eat();
        },"A").start();


        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        //线程B
        new Thread(()->{

            test.run();
        },"B").start();

    }
}

class Test {

    public synchronized void eat(){
        try{
            TimeUnit.SECONDS.sleep(3);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("============1=eat");
    }


    public void run(){
        System.out.println("============2=run");
    }
}

此时不需要争夺资源，A线程走完后 ，直接走run方法

结果：

============2=run
============1=eat

Process finished with exit code 0

再次修改，创建2个对象，不同对象调不同方法

public class Data {
    public static void main(String[] args) {
        Test test=new Test();
        Test test1=new Test();

        //线程A
        new Thread(()->{
            test.eat();
        },"A").start();


        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        //线程B
        new Thread(()->{
            test1.run();
        },"B").start();
    }
}

class Test {
    public synchronized void eat(){
        try{
            TimeUnit.SECONDS.sleep(3);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("============1=eat");
    }
    public synchronized void run(){
        System.out.println("============2=run");
    }
}

结果：

============2=run
============1=eat

Process finished with exit code 0

 

修饰静态方法示例：

public class Data {

    public static void main(String[] args) {

        Test test=new Test();
        Test test1=new Test();

        //线程A
        new Thread(()->{

            test.eat();
        },"A").start();
        
        try{
            TimeUnit.SECONDS.sleep(1);//睡眠1秒
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        //线程B
        new Thread(()->{

            test1.run();
        },"B").start();
    }
}

class Test {

    public synchronized static void eat(){
        try{
            TimeUnit.SECONDS.sleep(3);//睡眠3秒
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("============1=eat");
    }

    public synchronized static void run(){
        System.out.println("============2=run");
    }
}

结果：

============1=eat
============2=run

Process finished with exit code 0

此时需要等待 ，锁定的是Test类

再次修改：


public class Data {

    public static void main(String[] args) {

        Test test=new Test();
        Test test1=new Test();

        //线程A
        new Thread(()->{

            test.eat();
        },"A").start();

        try{
            TimeUnit.SECONDS.sleep(1);//睡眠1秒
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        //线程B
        new Thread(()->{

            test1.run();
        },"B").start();
    }
}

class Test {

    public synchronized static void eat(){
        try{
            TimeUnit.SECONDS.sleep(3);//睡眠3秒
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("============1=eat");
    }

    public static void run(){
        System.out.println("============2=run");
    }
}

结果：b线程调取方法没有 synchronized 不用锁定 直接执行就可以了

============2=run
============1=eat

Process finished with exit code 0

  • 修饰方法：

(1).静态方法 ：锁定的是类
(2).非静态方法：锁定的是方法的调用者

  • 修饰代码块

锁定是传入的对象


 

 

 

 

 

 

 

 

 

锁进阶 -- synchronized 的锁优化
想听风雨的博客
12-11 873
介绍 synchronized 锁的优化，包括锁升级、锁消除、锁粗化。
synchronized 到底锁的是谁？
pingfanblog
11-05 419
synchronized 到底锁的是谁？修饰方法：1、静态方法2、非静态方法，锁住的是方法的调用者修饰代码块。
Synchronized到底锁住的是谁？
weixin_33874713的博客
06-19 203
先来一道并发编程笔试题 题目：利用5个线程并发执行，num数字累计计数到10000，并打印。 /** * Description: * 利用5个线程并发执行，num数字累加计数到10000，并打印。 * 2019-06-13 * Created with OKevin. */ public class Count { private int num = 0; public stati...
synchronized你到底锁住的是谁？
NWPU_LIUBO的博客
11-28 266
synchronized你到底锁住的是谁？ synchronized从语法的维度一共有3个用法： 1.静态方法加上关键字 2.实例方法（也就是普通方法）加上关键字 3.方法中使用同步代码块 synchronized从锁的是谁的维度一共有两种情况： 1.锁住类 2.锁住对象实例 我们还是从直观的语法结构上来讲述synchronized。 1）静态方法上的锁 静态方法是属于“类”，不属于某个...
并发编程中Synchronized锁的七个问题 带你了解锁的究竟是谁
weixin_43788143的博客
01-19 2596
锁能锁的东西只有两个，一个是new出来的对象， 另一个是Class模板
synchronized锁住的到底是谁？
qq_41710400的博客
08-18 254
我看了下面一位博主的博客，感觉讲解的很详细，转载过来收藏 https://www.cnblogs.com/yulinfeng/p/11020576.html
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
Java 中 Synchronized（对象锁）和 Static Synchronized（类锁）的区别 Synchronized 和 Static Synchronized 是 Java 中两种同步机制，它们都用于解决多线程并发访问的安全问题。然而，它们之间存在着本质的区别。...
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
《深入剖析synchronized锁原理——从Java对象头的角度》 synchronized关键字在Java中扮演着重要的角色，它是Java实现同步的基础，确保了多线程环境下的数据一致性。不同于基于JDK实现的Lock接口（如ReentrantLock）...
synchronized枷锁实例
07-05
本文将深入探讨`synchronized`关键字的用法，包括类锁、对象锁、方法锁以及它们之间的关系。 **类锁（Class Lock）** 类锁是通过类的Class对象实现的，当一个线程访问类的静态 synchronized 方法或同步代码块时，就...
Java并发 synchronized锁住的内容解析
08-25
Java并发synchronized锁住的内容解析 Java并发synchronized锁住的内容解析是Java并发编程中的一种重要机制，用于解决多线程并发访问同一个资源时可能出现的线程安全问题。通过使用synchronized关键字，可以锁住当前...
synchronized到底锁住的是谁？
weixin_39038328的博客
04-04 1033
我们使用synchronized关键字是用来实现线程同步的，当多个线程同时去争抢同一个资源的时候在资源上边加一个synchronized关键字，能够使得线程排队去完成操作。
synchronized到底锁的是谁？
超级氯化钾的博客
10-15 621
synchronized实现线程同步，让多个线程排队以此获取某个资源，保证数据不会出错。
synchronized 锁谁的问题
weixin_44089714的博客
09-27 135
转暂：https://www.cnblogs.com/yulinfeng/p/11020576.html 讲的很棒
synchronized锁住了谁
yaotai8135的博客
10-24 358
先来看一段代码 public class MultiThread { private static int num = 0; /** static */ public synchronized void printNum(String tag){ try { if(tag.equals("a")){ num = 200; System.out.pri...
synchronized锁住的到底是谁？？？
qq_60264381的博客
05-06 812
类声明后，new出来的实例对象，在堆中都有自己的独立空间和引用地址，这时候我们可以认为这些实例都是。而静态成员(static修饰的成员、方法)是跟类一起加载的，也是存放在方法区，被所有线程共享。在静态方法上进行了声明则锁的是这个类，也就是我们常说的。，所以在实例上加的锁与其它的实例就没有关系，互不影响。从锁的是谁的纬度上一共有两种情况；的，所以类也是被所有线程共享的。类信息是存放在方法区的，整个JVM中只有一份。
Jvm: synchronized锁定谁？
amadeus_liu2的博客
08-05 207
jvm
synchronized：锁的对象到底是谁？快速理解八锁现象
saya21的博客
07-24 1291
通过总结和例子帮助快速理解八锁现象。
synchronized的锁对象是什么
最新发布
09-23
在 Java 中，任何对象都可作为锁，Synchronized 的使用主要有三种情况，对应的锁对象各不相同： 1. **普通同步方法**：对于普通同步方法，锁的是当前实例对象。这意味着当一个线程进入一个对象的普通同步方法时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我先来一碗

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

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

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

打赏作者

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

抵扣说明：

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

余额充值