synchronized 修饰普通方法与静态方法的区别

最新推荐文章于 2024-04-12 15:36:07 发布

原创最新推荐文章于 2024-04-12 15:36:07 发布 · 1.7k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#java #后端

java基础学习专栏收录该内容

19 篇文章

订阅专栏

本文通过三个示例详细解析了Java中synchronized修饰普通方法和静态方法时的不同效果。当修饰普通方法时，锁住的是对象实例，不同对象可以并发执行；而修饰静态方法时，锁住的是类，导致所有对象执行该方法时都会互斥。

面试时候被问的问题，当时脑子里闪了一下，但是没答出来

先说结论：

synchronized 修饰普通方法时，锁的是当前对象的方法，等价于 synchronized (this)
synchronized 修饰静态方法时，锁的是所有对象的方法，等价于 synchronized （Xxx.class）

我们知道，普通方法从属于对象，而静态方法从属于类
带着疑惑，来看代码吧

情景1：当 synchronized 修饰普通方法后，同一个对象被两个线程调用结果

public class TestMain {
    public static void main(String[] args) {
        //测试 synchronized 修饰普通方法
        Person person1 = new Person();

        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("t1开始");
                person1.work("t1线程老板 叫person1 工作啦");
                System.out.println("t1结束");
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                System.out.println("t2开始");
                person1.work("t2线程老板 叫person1 工作啦");
                System.out.println("t2结束");
            }
        };
        t1.start();
        t2.start();

    }
}
class Person{

    //输出10次value work 方法
    public synchronized void work(String value){
        for (int i=0;i<10;i++){
            System.out.println(value + i );
            try {
                Thread.sleep(250);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

打印结果

t1开始
t2开始
t1线程老板 叫person1 工作啦0
t1线程老板 叫person1 工作啦1
t1线程老板 叫person1 工作啦2
t1线程老板 叫person1 工作啦3
t1线程老板 叫person1 工作啦4
t1线程老板 叫person1 工作啦5
t1线程老板 叫person1 工作啦6
t1线程老板 叫person1 工作啦7
t1线程老板 叫person1 工作啦8
t1线程老板 叫person1 工作啦9
t1结束
t2线程老板 叫person1 工作啦0
t2线程老板 叫person1 工作啦1
t2线程老板 叫person1 工作啦2
t2线程老板 叫person1 工作啦3
t2线程老板 叫person1 工作啦4
t2线程老板 叫person1 工作啦5
t2线程老板 叫person1 工作啦6
t2线程老板 叫person1 工作啦7
t2线程老板 叫person1 工作啦8
t2线程老板 叫person1 工作啦9
t2结束

上面代码我们可以看到，虽然 t1 和 t2 线程都开始了，但是 t2 线程并没有打断 t1 线程执行wok1 方法（注意此时都是person1 一个对象）

情景2：synchronized 修饰普通方法后，不同对象被不同的线程调用结果


public class TestMain {
    public static void main(String[] args) {
        //测试 synchronized 修饰普通方法
        Person person1 = new Person();
        Person person2 = new Person();  // 修改 

        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("t1开始");
                person1.work("t1线程老板 叫person1 工作啦");
                System.out.println("t1结束");
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                System.out.println("t2开始");
                person2.work("t2线程老板 叫person2 工作啦"); // 修改
                System.out.println("t2结束");
            }
        };
        t1.start();
        t2.start();

    }
}
class Person{

    //输出10次value work1 方法
    public synchronized void work(String value){
        for (int i=0;i<10;i++){
            System.out.println(value + i );
            try {
                Thread.sleep(250);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

t1开始
t2开始
t1线程老板 叫person1 工作啦0
t2线程老板 叫person2 工作啦0
t1线程老板 叫person1 工作啦1
t2线程老板 叫person2 工作啦1
t2线程老板 叫person2 工作啦2
t1线程老板 叫person1 工作啦2
t1线程老板 叫person1 工作啦3
t2线程老板 叫person2 工作啦3
t1线程老板 叫person1 工作啦4
t2线程老板 叫person2 工作啦4
t2线程老板 叫person2 工作啦5
t1线程老板 叫person1 工作啦5
t1线程老板 叫person1 工作啦6
t2线程老板 叫person2 工作啦6
t2线程老板 叫person2 工作啦7
t1线程老板 叫person1 工作啦7
t1线程老板 叫person1 工作啦8
t2线程老板 叫person2 工作啦8
t1线程老板 叫person1 工作啦9
t2线程老板 叫person2 工作啦9
t2结束
t1结束

我们可以看到，这两个对象的方法在执行的过程中都被打断了

情景3 ：情景2 的基础上使用 static 修饰work方法

package com.demo06;

public class TestMain {
    public static void main(String[] args) {
        //测试 synchronized 修饰普通方法
        Person person1 = new Person();
        Person person2 = new Person();  // 修改

        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("t1开始");
                person1.work("t1线程老板 叫person1 工作啦");
                System.out.println("t1结束");
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                System.out.println("t2开始");
                person2.work("t2线程老板 叫person2 工作啦"); // 修改
                System.out.println("t2结束");
            }
        };
        t1.start();
        t2.start();

    }
}
class Person{

    //输出10次value work1 方法
    public static synchronized void work(String value){ //改动
        for (int i=0;i<10;i++){
            System.out.println(value + i );
            try {
                Thread.sleep(250);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

t2开始
t2线程老板 叫person2 工作啦0
t1开始
t2线程老板 叫person2 工作啦1
t2线程老板 叫person2 工作啦2
t2线程老板 叫person2 工作啦3
t2线程老板 叫person2 工作啦4
t2线程老板 叫person2 工作啦5
t2线程老板 叫person2 工作啦6
t2线程老板 叫person2 工作啦7
t2线程老板 叫person2 工作啦8
t2线程老板 叫person2 工作啦9
t2结束
t1线程老板 叫person1 工作啦0
t1线程老板 叫person1 工作啦1
t1线程老板 叫person1 工作啦2
t1线程老板 叫person1 工作啦3
t1线程老板 叫person1 工作啦4
t1线程老板 叫person1 工作啦5
t1线程老板 叫person1 工作啦6
t1线程老板 叫person1 工作啦7
t1线程老板 叫person1 工作啦8
t1线程老板 叫person1 工作啦9
t1结束