4.如何判断锁的是谁：八个锁的问题

感谢秦疆老师的JUC并发编程视频，更多了解哔哩哔哩搜索【狂神说Java】。

本文内容源于秦疆老师的JUC并发编程视频教程。给狂神推荐，点赞吧！

关于锁的八个问题深刻理解我们的锁

如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！

1.标准情况下，两个线程先打印发短信还是打电话

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 1.标准情况下，两个线程先打印 发短信 还是打电话
 */
public class TestLock1 {

    public static void main(String[] args) {

        Phone phone = new Phone();

        new Thread(()->{phone.sendSms();},"A").start();


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(()->{phone.call();},"B").start();

    }
}


class Phone{


    public synchronized void sendSms(){
        System.out.println("发短信！");
    }

    public synchronized void call(){
        System.out.println("打电话！");
    }


}


//输出：
发短信！
打电话！

2.sendSms()延迟4s情况下，两个线程先打印发短信还是打电话？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 2.sendSms（）延迟4s情况下，两个线程先打印 发短信 还是打电话 ？
 */
public class TestLock1 {

    public static void main(String[] args) {

        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.call();
        }, "B").start();

    }
}


class Phone {


    public synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    public synchronized void call() {
        System.out.println("打电话！");
    }


}


//输出：
发短信！
打电话！

分析：

Phone phone = new Phone();
new Thread(() -> {phone.sendSms(); }, "A").start();
new Thread(() -> {phone.call(); }, "B").start();

synchronized 锁的存在 锁的对象是方法的调用者！
两个方法用的是同一把锁，谁先拿到就谁先执行！

3.增加一个普通方法hello（） ,线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 *3.增加一个普通方法hello（） ,线程先打印哪个？
 */
public class TestLock2 {

    public static void main(String[] args) {

        Phone2 phone = new Phone2();

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }


        new Thread(() -> {
            phone.call();
        }, "B").start();
        
           new Thread(() -> {
            phone.hello();
        }, "c").start();


    }
}


class Phone2 {


    public synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    public synchronized void call() {
        System.out.println("打电话！");
    }

    //普通方法 这里没有锁 不是同步方法，不受锁的影响
    public  void hello() {
        System.out.println("hello,你好！");
    }

}


//输出：
hello,你好！
发短信！
打电话！

4.两个对象，两个同步方法，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 *4.两个对象，两个同步方法，线程先打印哪个？
 */
public class TestLock2 {

    public static void main(String[] args) {

        //两个对象
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.call();
        }, "B").start();

    }
}


class Phone2 {


    public synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    public synchronized void call() {
        System.out.println("打电话！");
    }

    //普通方法 这里没有锁 不是同步方法，不受锁的影响
    public  void hello() {
        System.out.println("hello,你好！");
    }

}


//输出：
打电话！ 
发短信！

5.增加两个静态的同步方法，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 5.增加两个静态的同步方法，线程先打印哪个？
 */
public class TestLock3 {

    public static void main(String[] args) {

        Phone3 phone = new Phone3();

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.call();
        }, "B").start();

    }
}


//Phone3 唯一的一个class 对象  全局唯一
// Class<Phone3> phone3Class = Phone3.class;
class Phone3 {

    //static 静态方法 类一加载就有了！ Class模板
    //锁的是Class
    public  static synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    public  static synchronized void call() {
        System.out.println("打电话！");
    }


}


//输出：
发短信！
打电话！

6.两个对象，增加两个静态的同步方法，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 6.两个对象，增加两个静态的同步方法，线程先打印哪个？
 */
public class TestLock3 {

    public static void main(String[] args) {
        //两个对象的Class类模板只有一个 static 锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.call();
        }, "B").start();

    }
}


//Phone3 唯一的一个class 对象  全局唯一
// Class<Phone3> phone3Class = Phone3.class;
class Phone3 {

    //static 静态方法 类一加载就有了！ Class模板
    //锁的是Class
    public  static synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    public  static synchronized void call() {
        System.out.println("打电话！");
    }


}


//输出：
发短信！
打电话！

7.一个静态的同步方法,一个普通的同步方法,一个对象，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 7.一个静态的同步方法,一个普通的同步方法,线程先打印哪个？
 */
public class TestLock4 {

    public static void main(String[] args) {
        //
        Phone4 phone = new Phone4();

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.call();
        }, "B").start();

    }
}



class Phone4 {


    //static 静态的同步方法 锁的是 Class模板 类一加载就有了！
    public  static synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    //普通同步方法 锁的是资源
    public  synchronized void call() {
        System.out.println("打电话！");
    }


}

//输出：
打电话！
发短信！

8.一个静态的同步方法,一个普通的同步方法,两个对象，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 8.一个静态的同步方法,一个普通的同步方法,两个对象，线程先打印哪个？
 */
public class TestLock4 {

    public static void main(String[] args) {
        //两个对象
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();


        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.call();
        }, "B").start();

    }
}



class Phone4 {


    //static 静态的同步方法 锁的是 Class模板 类一加载就有了！
    public  static synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    //普通同步方法 锁的是资源
    public  synchronized void call() {
        System.out.println("打电话！");
    }


}



//输出：
打电话！
发短信！

小结

new this 具体的一个手机
static Class 唯一的一个模板

posted @ 2020-05-23 22:35 我有满天星辰阅读(5) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2.Lock锁

· Lock(锁)

· JUC并发编程学习笔记（四）8锁现象

· 2022.8.21 8锁的现象

· java编程开发多线程锁的8个问题分析

阅读排行：
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
· 字符编码：从基础到乱码解决

公告

昵称：我有满天星辰
园龄： 6年9个月
粉丝： 1
关注： 68

+加关注

2025年3月

日

一

二

三

四

五

六

我有满天星辰

你眼里有满天星辰，我眼里有你~ CSDN博客地址:https://blog.csdn.net/beiluoL

4.如何判断锁的是谁：八个锁的问题

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

我有满天星辰

你眼里有满天星辰，我眼里有你~ CSDN博客地址:https://blog.csdn.net/beiluoL

4.如何判断锁的是谁 ：八个锁的问题

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

4.如何判断锁的是谁：八个锁的问题