JUC-----------（三）详解synchronized八种情况

最新推荐文章于 2024-11-08 09:39:58 发布

转载最新推荐文章于 2024-11-08 09:39:58 发布 · 203 阅读

2 ·

CC 4.0 BY-SA版权

原文链接：https://www.bilibili.com/video/BV1B7411L7tE?p=34

文章标签：

#多线程 #并发编程 #java

Java 同时被 2 个专栏收录

17 篇文章

订阅专栏

JUC

7 篇文章

订阅专栏

本文通过多个实例详细解析了Java中synchronized关键字的使用方法及锁的实现原理，包括同步方法的锁对象、静态同步方法的锁对象等概念，并探讨了不同情况下线程间的等待与执行顺序。

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

8锁现象

1、标准访问，请问先打印邮件还是短信

public class A {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}
class Phone{
    public synchronized void sendEmail() {
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

结论：被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行。

2、邮件方法暂停4秒钟，请问先打印邮件还是短信？

public class B {
    public static void main(String[] args) {
        Phone1 phone = new Phone1();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}
class Phone1{
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

结论：被synchronized修饰的方法，所得对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行，第二个方法只有在第一个方法执行完释放锁之后才能执行。

3、新增一个普通方法hello()没有同步，请问先打印邮件还是hello？

public class C {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone = new Phone3();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        Thread.sleep(200);
        new Thread(() -> {
            phone.hello();
        }, "B").start();
    }
}
class Phone3{
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
    public void hello(){
        System.out.println("Hello");
    }
}

结论：新增的方法没有被synchronized修饰，不是同步方法，不受锁的影响，所以不需要等待。其他线程共用了一把锁，所以需要等待。

4、两部手机、请问先打印邮件还是短信？

public class D {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}
class Phone4{
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

结论：被synchronized修饰的方法，锁的对象是方法的调用者。因为用了两个都西昂调用各自的方法，所以两个方法的调用者不是同一个所以两个方法不是同一个锁，后调用的方法不需要等待先调用方法。

5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？

public class E {
    public static void main(String[] args) throws InterruptedException {
        Phone5 phone = new Phone5();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        Thread.sleep(200);
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}
class Phone5{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public static synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

结论：被synchronized和static修饰的方法，所得对象是类的class对象。因为两个同步方法都被static修饰，所以两个方法用的是同一个锁，后调用的方法需要等待先调用的方法。

6、两个静态同步方法，两部手机，请问先打印邮件还是短信？

public class F {
    public static void main(String[] args) {
        Phone6 phone1 = new Phone6();
        Phone6 phone2 = new Phone6();
        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}
class Phone6{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public static synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。因为两个同步方法都被static修饰了，即便用了两个不同的对象调用方法，两个方法用的还是同一个锁，后调用的方法需要等待先调用的方法。

7、一个普通的方法，一个静态的方法，同一部手机，请问先打印邮件还是短信？

public class G {
    public static void main(String[] args) throws InterruptedException {
        Phone7 phone = new Phone7();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        Thread.sleep(200);
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}
class Phone7{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。仅仅被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法锁的对象不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

8、1个普通同步方法、1个静态同步方法，2部手机，请问先打印邮件还是短信？

public class H {
    public static void main(String[] args) {
        Phone8 phone1 = new Phone8();
        Phone8 phone2 = new Phone8();
        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}
class Phone8{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}