Java那些“锁”事 - “八锁”案例

于 2023-07-26 00:15:30 发布
阅读量123 收藏
点赞数
分类专栏： Java并发编程 文章标签： 类锁 对象锁 Class Lock Object Lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27062249/article/details/131926778
版权

阿里巴巴规范手册中有提到：高并发时，同步调用应该去考量锁的性能消耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。

“八锁”案例

案例一

        有一个Phone资源类，该资源类包含一个被synchronized修饰的发邮件方法和另一个synchronized修饰的发短信方法：

/**
 * 资源类
 */
class Phone {

    /**
     * 发邮件
     */
    public synchronized void sendEmail() {
        System.out.println("sendEmail success");
    }
    /**
     * 发短信
     */
    public synchronized void sendSMS() {
        System.out.println("sendSMS success");
    }
}

        只有有一部手机，A线程发邮件，B线程发短信。先发送邮件还是先发送短信？

    public static void main(String[] args) {

        Phone phone1 = new Phone();

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

        //保证A线程早于B线程启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone1.sendSMS();
        }, "B").start();
    }

       打印结果：

sendEmail success
sendSMS success

        结论很简单，A线程和B线程争抢的是同一个锁对象，这里的锁对象是phone1对象锁(Object Lock)。所以会先发送邮件，然后在发送短信。

案例二

         有一个Phone资源类，该资源类包含一个被synchronized修饰的发邮件方法，发送邮件的方法延时3秒和另一个synchronized修饰的发短信方法：

/**
 * 资源类
 */
class Phone {

    /**
     * 发邮件
     */
    public synchronized void sendEmail() {
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("sendEmail success");
    }
    /**
     * 发短信
     */
    public synchronized void sendSMS() {
        System.out.println("sendSMS success");
    }
}

          只有有一部手机，A线程发邮件，B线程发短信。先发送邮件还是先发送短信？

    public static void main(String[] args) {

        Phone phone1 = new Phone();

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

        //保证A线程早于B线程启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone1.sendSMS();
        }, "B").start();

    }

        打印结果：

sendEmail success
sendSMS success

         结论很简单，A线程和B线程争抢的是同一个锁对象，这里的锁对象是phone1对象锁(Object Lock)。即使发邮件方法延时3秒钟，但是A线程依然持有phone1对象锁。所以会先发送邮件，然后在发送短信。

案例三

         有一个Phone资源类，该资源类包含一个被synchronized修饰的发邮件方法，发送邮件的方法延时3秒和另一个普通的发送短信的方法：

/**
 * 资源类
 */
class Phone {

    /**
     * 发邮件
     */
    public synchronized void sendEmail() {
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("sendEmail success");
    }
    /**
     * 发短信
     */
    public  void sendSMS() {
        System.out.println("sendSMS success");
    }
}

        只有一部手机，A线程调用发邮件方法，B线程调用发短信方法。先发送邮件还是先发送短信？

    public static void main(String[] args) {

        Phone phone1 = new Phone();
        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();

        //保证A线程早于B线程启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone1.sendSMS();
        }, "B").start();

    }

        打印结果：

sendSMS success
sendEmail success

        可以看到，先发送了短信，再发送了邮件。因为发送短信方法并没有加锁，所以B线程在调用发送短信方法时并不存在锁的抢占。

案例四

         有一个Phone资源类，该资源类包含一个被synchronized修饰的发邮件方法和另一个synchronized修饰的发短信方法：

/**
 * 资源类
 */
class Phone {

    /**
     * 发邮件
     */
    public synchronized void sendEmail() {
        System.out.println("sendEmail success");
    }
    /**
     * 发短信
     */
    public synchronized void sendSMS() {
        System.out.println("sendSMS success");
    }
}

        有两部手机，A线程调用第一部手机的发邮件方法，B线程调用第二部手机的发短信方法。先发送邮件还是先发送短信？

    public static void main(String[] args) {

        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();

        //保证A线程早于B线程启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

        打印结果：

sendSMS success
sendEmail success

        这里的结论也很简单，因为这里A线程和B线程所持有的锁分别是phone1和phone2的对象锁，两个线程之间并不存在锁的抢占。所以发短信会在发邮件之前。

案例五

        有一个Phone资源类，该资源类包含一个被synchronized修饰的静态的发邮件方法和另一个synchronized修饰的静态的发短信方法：

/**
 * 资源类
 */
class Phone {

    /**
     * 发邮件
     */
    public  static  synchronized void sendEmail() {
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("sendEmail success");
    }

    /**
     * 发短信
     */
    public static synchronized void sendSMS() {
        System.out.println("sendSMS success");
    }
}

        只有一部手机，A线程调用发邮件方法，B线程调用发短信方法。先发送邮件还是先发送短信？

    public static void main(String[] args) {

        Phone phone1 = new Phone();
        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();

        //保证A线程早于B线程启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone1.sendSMS();
        }, "B").start();

    }

        打印结果：

sendEmail success
sendSMS success

        这里的结果和案例一的结果一样，先发送了邮件再发送了短信。因为，此时A线程和B线程所抢占的还是同一把锁，只不过这个时候锁对象变成了Phone的类锁(Class Lock)。所以，先发送了邮件，再发送了短信。

案例六

        有一个Phone资源类，该资源类包含一个被synchronized修饰的静态的发邮件方法和另一个synchronized修饰的静态的发短信方法：

/**
 * 资源类
 */
class Phone {

    /**
     * 发邮件
     */
    public  static  synchronized void sendEmail() {
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("sendEmail success");
    }

    /**
     * 发短信
     */
    public static synchronized void sendSMS() {
        System.out.println("sendSMS success");
    }
}

        两部手机，A线程调用第一部手机的发邮件方法，B线程调用第二部手机的发短信方法。先发送邮件还是先发送短信？

    public static void main(String[] args) {

        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

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

        //保证A线程早于B线程启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }

        结果打印：

sendEmail success
sendSMS success

        这里的结果和案例六的结果一样，虽然是两部手机，但是A线程和B线程抢占的还是同一个锁对象，就是Phone的类锁(Class Lock)。所以，先发送了邮件，再发送了短信。

案例七

        有一个Phone资源类，该资源类包含一个被synchronized修饰的静态的发邮件方法和另一个普通发短信方法：

/**
 * 资源类
 */
class Phone {

    /**
     * 发邮件
     */
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail success");
    }

    /**
     * 发短信
     */
    public  void sendSMS() {
        System.out.println("sendSMS success");
    }
}

        一部手机，A线程调用发邮件方法，B线程调用发短信方法。先发送邮件还是先发送短信？

    public static void main(String[] args) {

        Phone phone1 = new Phone();

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

        //保证A线程早于B线程启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone1.sendSMS();
        }, "B").start();

    }

        结果打印：

sendSMS success
sendEmail success

        经过前面几个案例之后，这里的结果就显得比价简单了。应为A线程和B线程不存在锁的抢占。所以就B线程先发送了短信，A线程再发送邮件。

案例八

        有一个Phone资源类，该资源类包含一个被synchronized修饰的静态的发邮件方法和另一个普通发短信方法：

/**
 * 资源类
 */
class Phone {

    /**
     * 发邮件
     */
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail success");
    }

    /**
     * 发短信
     */
    public  void sendSMS() {
        System.out.println("sendSMS success");
    }
}

        两部手机，A线程调用第一步手机发送邮件，B线程调用第二部手机的发送短信方法。先发送邮件还是先发送短信？

 public static void main(String[] args) {

        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

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

        //保证A线程早于B线程启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

        打印结果：

sendSMS success
sendEmail success

        该案例中的A线程持有的是Phone类锁(Class Lock),而B线程并不存在和A线程抢占锁的关系，所以先发送了短息，再发送了邮件。

通过上面几个案例，同学们对类锁(Class Lock)和对像锁(Object Lock)有一定的认识了吧。

大后生大大大
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java乐观锁原理与实现案例分析
08-25
主要介绍了java乐观锁原理与实现,结合具体案例形式分析了乐观锁的原理及java使用乐观锁实现自动派单功能的相关操作技巧,需要的朋友可以参考下
Java 多线程 线程8锁（含示例代码）
weixin_55871070的博客
04-17 692
以下内容根据视频https://www.bilibili.com/video/BV1vE411D7KE?p=6学习整理 1.标准访问 class Phone{ public synchronized void sendEmail() throws Exception { System.out.println("**sendEmail"); } public synchronized void sendSMS() throws Exception { ...
Java多线程——线程八锁案例分析
qq_15138049的博客
06-13 163
摘要：本文主要学习了多线程并发中的一些案例。 部分内容来自以下博客： https://blog.csdn.net/dyt443733328/article/details/80019352 多线程的八个案例 通过分析代码，推测打印结果，并运行代码进行验证。 1）两个线程调用同一个对象的两个同步方法 代码如下： 1 public class Demo { 2 public static void main(String[] args) { 3 Number ...
java 乐观锁 实例_JAVA乐观锁实现-CAS(示例代码)
weixin_30696229的博客
02-16 1550
是什么全称compare and swap，一个CPU原子指令，在硬件层面实现的机制，体现了乐观锁的思想。JVM用C语言封装了汇编调用。Java的基础库中有很多类就是基于JNI调用C接口实现了多线程同步更新的功能。原理CMS有三个操作数：当前主内存变量的值V，线程本地变量预期值A，线程本地待更新值B。当需要更新变量值的时候，会先获取到内存变量值V然后很预期值A进行比较，如果相同则更新为B，如果不同...
Java基于Redis实现的分布式锁---电商下单案例
qq_56892136的博客
11-06 2588
案例是一个简易版的电商项目中的下单功能，先简单分析下下单功能的一些基本步骤：1.校验库存 2.保存订单 3.生成快照 4.扣减库存 5.删除购物车。
悲观锁的实现方式java_并发编程--锁--悲观锁和乐观锁
weixin_30920223的博客
02-28 4939
悲观锁和乐观锁并不是某个具体的“锁”而是一种并发编程的基本概念，是根据看待并发同步的角度。乐观锁和悲观锁最早出现在数据库的设计当中，后来逐渐被 Java 的并发包所引入。悲观锁悲观锁认为对于同一个数据的并发操作一定是会发生修改的，采取加锁的形式，悲观地认为，不加锁的并发操作一定会出问题。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中...
Java Synchronized锁失败案例及解决方案
08-19
主要介绍了Java Synchronized锁失败案例及解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java多线程、锁的教程跟案例
12-01
详细描述了java的多线程跟锁的用法 并配多个demo
Java 同步锁(synchronized)详解及实例
08-30
主要介绍了Java 同步锁(synchronized)详解及实例的相关资料,需要的朋友可以参考下
Java多线程编程之读写锁ReadWriteLock用法实例
09-03
主要介绍了Java多线程编程之读写锁ReadWriteLock用法实例,本文直接给出编码实例,需要的朋友可以参考下
node-v10.22.0-darwin-x64.tar.xz
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于JAVA的物流管理系统的源码设计与实现.zip
05-03
毕业设计-->物流管理系统的设计与实现（Java版本） 采用Struts2+hibernate+Oracle10g+Tomcat 涉及车辆管理，配送点管理，运输方式管理，订单管理，员工管理，用户管理，部门管理，权限管理，角色管理等基础管理功能。
基于VB+access实现的成绩分析统计系统(论文+源代码).zip
05-03
基于VB+access实现的成绩分析统计系统(论文+源代码) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
node-v10.14.2-linux-x64.tar.xz
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
ASP+ACCESS网上购物系统设计(源代码+设计说明书+调研报告).zip
05-03
ASP+ACCESS网上购物系统设计(源代码+设计说明书+调研报告).zip
AO工艺设计计算(全).xls
05-03
污水处理计算书
node-v7.3.0-x86.msi
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
ASP+ACCESS在线考试系统设计(源代码+设计说明书).zip
05-03
ASP+ACCESS在线考试系统设计(源代码+设计说明书).zip
node-v11.10.0-linux-ppc64le.tar.xz
最新发布
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
java同步锁synchronized使用案例
08-30
总结来说，synchronized关键字在Java中的使用案例非常广泛，可以用于多线程环境下保证共享资源的安全访问，避免并发操作导致的数据不一致问题。通过使用synchronized，可以有效地控制多个线程对共享资源的访问，确保...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值