synchronized修饰静态方法和普通方法的区别 和 应用

已于 2022-08-30 14:19:40 修改
阅读量474 收藏
点赞数
文章标签： java jvm 面试
于 2022-08-29 16:25:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34654085/article/details/126586864
版权
synchronized 可以锁类方法（静态方法） 或者 普通方法

修饰普通方法

1.先看单个对象代码

package com.thread;

public class SynchronizedTest {

    synchronized public void function1() throws InterruptedException {
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 5; i++){
            System.out.println("function1 " + name);
            Thread.sleep(1000);
        }
    }

    synchronized public void function2() throws InterruptedException {
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 5; i++){
            System.out.println("function2 " + name);
            Thread.sleep(1000);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest s1 = new SynchronizedTest();

        new Thread(() -> {
            System.out.println("Thread1 is start");
            try {
                s1.function1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread1 is end");

        }).start();

        new Thread(() -> {
            System.out.println("Thread2 is start");
            try {
                s1.function2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread2 is end");

        }).start();
    }
}

z

首先看，我们创建的对象s1,在不同线程分别执行不同的两个普通方法(实例方法)，因为synchronized 锁住的是对象(对象锁)，所以按照执行顺序是function1 再试function2
纵然function2想去执行方法，但是，因为对象锁锁住的是s1对象，所以必须等到function1执行完毕function2中才能获得锁执行方法

2.再看多个对象代码

为了验证这个，我们再去建立一个对象s2,开启线程执行function2.
package com.thread;

public class SynchronizedTest {

    synchronized public void function1() throws InterruptedException {
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 5; i++){
            System.out.println("function1 " + name);
            Thread.sleep(1000);
        }
    }

    synchronized public void function2() throws InterruptedException {
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 5; i++){
            System.out.println("function2 " + name);
            Thread.sleep(1000);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest s1 = new SynchronizedTest();
        SynchronizedTest s2 = new SynchronizedTest();
        new Thread(() -> {
            System.out.println("Thread1 is start");
            try {
                s1.function1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread1 is end");

        }).start();

        new Thread(() -> {
            System.out.println("Thread2 is start");
            try {
                s1.function2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread2 is end");

        }).start();

        new Thread(() -> {
            System.out.println("Thread3 is start");
            try {
                s2.function2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread3 is end");

        }).start();
    }
}
执行结果如下

多个对象执行普通方法结果

丛中可以看出，对象二s2 并没有收到s1的影响，自己个儿跑自己个儿的方法了，所以说synchronized 修饰普通方法，仅仅对该实例对象有限制，其他对象不会有影响。所以锁住的是this 实例对象。

修饰类方法

直接上代码

package com.thread;

public class SynchronizedTest {

    synchronized public static void function1() throws InterruptedException {
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 5; i++){
            System.out.println("function1 " + name);
            Thread.sleep(1000);
        }
    }

    synchronized public static void function2() throws InterruptedException {
        String name = Thread.currentThread().getName();
        for (int i = 0; i < 5; i++){
            System.out.println("function2 " + name);
            Thread.sleep(1000);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedTest s1 = new SynchronizedTest();
        SynchronizedTest s2 = new SynchronizedTest();
        new Thread(() -> {
            System.out.println("Thread1 is start");
            try {
                s1.function1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread1 is end");

        }).start();

        new Thread(() -> {
            System.out.println("Thread2 is start");
            try {
                s1.function2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread2 is end");

        }).start();

        new Thread(() -> {
            System.out.println("Thread3 is start");
            try {
                s2.function2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread3 is end");

        }).start();
    }
}
运行结果如下

synchronized 修饰类方法

可以看出，不同类实例对象的执行按照顺序走了，也就是：虽然是不同的对象，但是s1 s2 都是同一个类的不同对象，这样的话，synchronized 修饰类方法(静态方法)，所有对象持有的都是一把锁，也就是SynchronizedTest.class

现有一段代码

public class TestStaticParam {
    private static Integer ticket = 100;
    public void ticket(){
        synchronized (this){
            while (ticket > 0){
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName()+":"+"减少前：" + ticket +"减少后："+(--ticket));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        TestStaticParam p1 = new TestStaticParam();
        TestStaticParam p2 = new TestStaticParam();
        new Thread(() -> p1.ticket()).start();
        new Thread(() -> p2.ticket()).start();
    }
}
synchronized 锁住的是this , 该方法是一个普通实例方法，所以this值得也就是实例变量，最后执行的结果肯定有问题！因为所得是实例变量，两个变量互不干扰，肯定影响数据ticket！
如何解决？

1.synchronized this 改成 当前类.class,也就是TestStaticParam .class,这样，按照之前讲过的，该锁就锁住了整个TestStaticParam ，而两个实例变量都是该类产生的，所以，线程跑起来只有线程一 抢到了锁，只想完毕整个循环就结束了！没有线程2什么事

2.synchronized 改成ticket ，这样，锁住的就是 该ticket 对象，两个线程谁抢到该锁，谁就先执行，而synchronized 具有原子性和可见性，从而达到了保护ticket 数据的目的

总结：

synchronized 可以修饰实例方法，也可以修饰静态方法。修饰实例方法的时候，锁住的是this当前对象；修饰类方法（静态方法）的时候，锁住的是XXX.class 也就是当前类

Peter20150926
关注
【Android面试八股文】synochnized修饰普通方法和静态方法的区别?什么是原子性、可见性、有序性?
字节卷动
06-08 352
是否了解Java并发编程的相关知识synchronized 关键字可以修饰方法，也可以使用 synchronized(obj) {} 定义同步代码块。通过修饰方法或代码块，可以确保在同一时间只有一个线程能够访问被修饰的代码，从而保证线程安全。正确的方式是使用 synchronized(this) 来锁定当前实例对象，以及使用 synchronized(Classname.class) 来锁定当前类对象。
多线程 - synchronized修饰实例方法、修饰静态方法、修饰代码块
学无止境
05-04 309
static synchronized 和 synchronized 修饰普通方法的区别在于：static synchronized 是在类级别上获取锁，而 synchronized 是在对象级别上获取锁。在 static synchronized 方法中，获取的是类级别的锁，不同的对象共享该锁，只有当一个线程持有该类的锁时，才能够调用该类的其他 static synchronized 方法。
基于synchronized修饰静态和非静态方法
08-19
主要介绍了基于synchronized修饰静态和非静态方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
synchronized修饰静态方法与实例方法
时光如白驹过隙的博客
09-02 4808
一、synchronized修饰实例方法： synchronized修饰实例方法，实际上是对调用该方法的对象加锁。 场景1：同一实例对象在两个线程中分别调用该对象的两个同步实例方法 public class Car { public synchronized void runing1(Thread thread){ System.out.println(thread.getName()+ " car1 得到锁"); System.out.println("------
Java中，synchronized修饰的静态方法会对整个对象加锁，这个是怎么实现的？
最新发布
m0_58466443的博客
08-02 305
当多个线程同时调用同一个类的静态方法时，JVM会使用这个监视器来确保只有一个线程可以进入方法内部。如果另一个线程试图在第一个线程正在执行方法时进入该方法，它会进入阻塞状态，直到第一个线程完成方法执行并释放监视器。这种实现方式的好处是，它可以确保所有对静态资源的访问都是线程安全的，而不需要为每个对象实例创建额外的同步机制。当一个静态方法被同步时，JVM会在。这意味着当多个线程同时调用这个方法时，只有一个线程可以执行方法体，确保了。关键字修饰时，它会锁定整个类，而不是对象实例。对象，这个对象在类加载时被创建。
synchronized修饰静态方法
weixin_42866896的博客
10-07 455
/** 同步线程 */ class SyncThread implements Runnable { private static int count; public SyncThread() { count = 0; } public synchronized static void method() { for (int i = 0; i &lt; 5; i ++) { try { Sys...
【多线程面试题十五】、synchronized可以修饰静态方法和静态代码块吗？
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
10-30 576
主要分享开发知识、学习资料、毕业设计指导等。有兴趣的可以关注一下。踩过的坑没必要让别人在再踩，自己复盘也能加深记忆。利己利人、所谓双赢。当修饰静态方法时，监视器锁（monitor）便是对象的Class实例，因为Class数据存在于永久代，因此静态方法锁相当于该类的一个全局锁。synchronized可以修饰静态方法，但不能修饰静态代码块。
synchronized修饰静态方法和非静态方法有区别
05-13
是的，synchronized修饰静态方法和非静态方法有区别。 当synchronized修饰非静态方法时，它锁定的是该方法所属对象的实例，也就是说，每个对象实例都有自己的锁。当一个线程进入该方法时，它会尝试获取该对象实例的...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
本文将深入探讨synchronized修饰方法在Java中的使用及其工作原理，并通过实例演示其应用。 1. **synchronized原理** synchronized基于Java的内置锁（也称为对象锁或 monitors）机制。当一个线程进入synchronized...
Java Synchronized修饰静态方法普通方法和代码块
linghaidong的专栏
04-20 3254
Class A {     public synchronized methodA() {//对当前对象加锁     }     public  methodB() {                synchronized(this){}//对当前对象加锁，与methodA用法相同     }     public static synchronized methodC()
synchronized修饰普通方法和静态方法
浪克oo的博客
03-25 942
两者区别： synchronized修饰普通方法：锁对象为当前实例对象(this) synchronized修饰静态方法：锁对象为当前类的字节码文件对象 具体例子如下： synchronized修饰普通方法 public class Animal { public synchronized void isDog() { Log.d("TAG", "isDog...
静态方法使用SYNCHRONIZED修饰.
黑马程序员广州中心的专栏
02-19 665
package seday10; /** * @author xingsir * 静态方法若使用synchronized修饰,这个方法一定具有同步效果。静态方法上使用的同步监视器对象为这个类的"类对象"， * 每个java定义的类都只有唯一的一个类对象(Class类型的的实 例) */ public class syncDemo3 { public static void main(String[...
synchronized修饰方法
with_luck的博客
07-22 6238
文章目录前言一、Synchronized修饰非静态方法二、Synchronized修饰静态方法三、类锁和对象锁的访问是不冲突的四、总结 前言 直接说结论： 1.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。 2.Synchronized修饰静态方法，实际上是对该类对象加锁，俗称“类锁”。 3.对于类锁synchronized static，是通过该类直接调用加类锁的方法，而对象锁是创建对象调用加对象锁的方法，两者访问是不冲突的，对于同一类型锁锁住的方法，同一对象是
synchronized修饰静态方法默认用本类的类名作为锁实现线程同步(锁功能/线程安全)
qq_43079667的博客
06-04 204
案例1：synchronized修饰静态方法 public class DemowenApplication extends Thread { public void run() { Mm bb = new Mm(); bb.mm(); } public static void main(String[] args) { for (int i = 0; i < 3; ++i) { Thread thread = new DemowenApplication()
synchronized修饰普通方法和修饰静态方法
hoji_James的博客
09-04 1022
1.前言 多线程这方面的学习参考的是《多线程编程核心技术》(高洪岩 著)这本书，可以说通过这本书，对多线程方面有了更多的了解，特别是书中对synchronized关键字和Lock锁的介绍方面，用了很大篇幅，在篇幅中也穿插了很多例子帮助理解，其中有一个结论当初记得特别深刻，那就是synchronized修饰静态方法和修饰普通方法时的区别。 2.困惑 第一遍学习时，只能说大概记住了结论就是syn...
synchronized修饰普通方法和静态方法区别
MrLiar的博客
08-11 1243
synchronized关键字修饰普通方法时，获得的锁是对象锁，也就是this对应的实例，如果多个线程通过不同的对象来调用方法，那么他们的锁就是不一样的，不会造成阻塞。 而修饰静态方法时，锁是类锁，也就是类名.class，多个线程调用该类的同步的静态方法时，都会阻塞。 ...
多线程：Synchronized的使用（一）——修饰方法、静态方法、代码块
weixin_41975299的博客
10-20 3597
Synchronized是什么？ Synchronized是Java的关键字，字面意思上是同步的意思，也就是说可以用它修饰普通方法、静态方法、代码块，达到同步的效果，就是我们俗称的上锁。 Synchronized作用域和作用对象？ 使用Synchronized修饰普通方法 使用Synchronized修饰普通方法，作用域是整个方法，作用对象是该类的当前对象，不同对象会持有不同的锁。下面我们来看看代码： public class SynchronizedMethodTest { sync
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值