通过8种加锁情况来弄懂加锁对于线程执行顺序的影响

  • 1个资源类对象，2个线程，2个同步方法，第二个线程等待1s后开启。
//资源类
public class Example {
    //2个同步方法
    public synchronized void method1(){
        System.out.println("线程1正在执行...");
    }

    public synchronized void method2(){
        System.out.println("线程2正在执行...");
    }
}

//开启线程
public class Main {
    public static void main(String[] args) throws InterruptedException {
        //1个资源类对象
        Example example=new Example();

        //创建并开启2个线程
        new Thread(()->{
            example.method1();
        }).start();

        //第二个线程延时1s创建并开启
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            example.method2();
        }).start();
    }
}

        先输出那个语句呢？

        运行结果：

        线程1和线程2使用的是同一个对象调用的同步方法，所以这两个线程需要竞争同一个锁。而线程1先运行，线程2延迟1s后才被创建，所以这1s期间只有线程1在竞争锁，就必然是线程1先获得锁，线程2只能等待线程1执行完后才能获得锁，然后才可以执行。这里面锁是很重要的，如果没有锁线程2完全可以在线程1执行期间抢夺CPU的占用权，并且如果线程1和线程2都需要较长的运行时间，那么谁最后执行完就不一定了。

  • 1个资源类对象，2个线程，2个同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {
    //2个同步方法
    public synchronized void method1() throws InterruptedException {
        //开启后先休眠3s
        TimeUnit.SECONDS.sleep(3);
        System.out.println("线程1正在执行...");
    }

    public synchronized void method2(){
        System.out.println("线程2正在执行...");
    }
}

//开启两个线程
public class Main {
    public static void main(String[] args) throws InterruptedException {
        //1个资源类对象
        Example example=new Example();

        //创建并开启2个线程
        new Thread(()->{
            try {
                example.method1();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();

        //第二个线程延时1s创建并开启
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            example.method2();
        }).start();
    }
}

        先输出那个语句呢？

        运行结果：

        对比上面的情况，线程1在开启后先休眠3s，这对于执行结果是没有影响的。因为线程在调用sleep后进入计时等待状态，在此状态下如果已经获取了锁则不会释放，也就是抱着锁睡觉；区别于wait，调用wait后线程进入等待状态，在此期间如果之前已经获得了锁则会释放。 所以虽然休眠了3s，但线程1仍旧持有锁，线程2只能等待。

  • 1个资源类对象，2个线程，1个同步方法+1个普通方法，第一个线程开启后休眠3s。
//资源类
public class Example {
    //1个同步方法
    public synchronized void method1() throws InterruptedException {
        //开启后休眠3s            
        TimeUnit.SECONDS.sleep(3);
        System.out.println("线程1正在执行...");
    }

    //1个普通方法
    public void method2(){
        System.out.println("线程2正在执行...");
    }
}

//创建两个线程
public class Main {
    public static void main(String[] args) throws InterruptedException {
        //1个资源类对象
        Example example=new Example();

        //创建并开启2个线程
        new Thread(()->{
            try {
                example.method1();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();
        new Thread(()->{
            example.method2();
        }).start();
    }
}

        先输出那个语句呢？

        运行结果：

        虽然线程1先获得了锁，并且sleep休眠期间也持有锁，但线程2调用的方法是普通方法，不需要获得锁即可执行。加锁只能防止其他需要获得同一把锁的线程，并不能防止不需要锁或者需要其他锁的线程，所以这种情况下锁就没有用了，线程1先获得了CPU占用权，随后休眠期间CPU被线程2抢走并执行，3s足以让线程2执行完毕，休眠结束后线程1再执行。

  • 2个资源类对象分别开启1个线程，2个同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {
    //2个同步方法
    public synchronized void method1() throws InterruptedException {
        //先休眠3s
        TimeUnit.SECONDS.sleep(3);
        System.out.println("线程1正在执行...");
    }

    public synchronized void method2(){
        System.out.println("线程2正在执行...");
    }
}

//创建两个线程
public class Main {
    public static void main(String[] args) throws InterruptedException {
        //2个资源类对象
        Example example1=new Example();
        Example example2=new Example();
        
        //2个资源类对象分别创建并开启1个线程
        new Thread(()->{
            try {
                example1.method1();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();

        //第二个线程等待1s后创建
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            example2.method2();
        }).start();
    }
}

        先输出那个语句呢？

        运行结果：

        非静态同步方法使用的锁对象是this，也就是方法的调用者，而本案例中使用的是两个不同的资源类对象分别创建的线程，所以两个同步方法使用的锁对象是不一样的，第一个线程使用的锁对象是example1，第二个使用的是example2；上面的案例中谈到加锁并不能防止不需要锁或者需要其他锁的线程，所以虽然线程1先抢到了锁，但是在休眠的3s内CPU是线程2的，并且线程2需要获取的是另一把锁，这就使得线程2会比线程1先执行完。

  • 1个资源类对象，2个线程，2个静态同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {
    //2个静态同步方法
    public static synchronized void method1() throws InterruptedException {
        //先休眠3s
        TimeUnit.SECONDS.sleep(3);
        System.out.println("线程1正在执行...");
    }

    public static synchronized void method2(){
        System.out.println("线程2正在执行...");
    }
}

//创建两个线程
public class Main {
    public static void main(String[] args) throws InterruptedException {
        //1个资源类对象
        Example example=new Example();

        //创建并开启2个线程
        new Thread(()->{
            try {
                example.method1();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();

        //第二个线程等待1s后创建
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            example.method2();
        }).start();
    }
}

        先输出那个语句呢？

        运行结果：

        静态同步方法的锁对象使用的是类的Class对象，而这个Class对象一个类只有一个，所以同一个类下所有静态同步方法的锁对象是同一个，即这个类的Class对象。那为什么会选择Class对象作为锁呢？这是因为静态方法和Class对象在类加载阶段就已经加载好了，但创建的对象需要等到类加载后执行到创建对象的代码时才会创建，只能选择Class对象作为锁对象。

        既然锁对象是同一个，并且线程1先抢到锁，那必然是线程1先执行，线程2后执行了。

  • 2个资源类对象分别开启1个线程，2个静态同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {
    //2个静态同步方法
    public static synchronized void method1() throws InterruptedException {
        //先休眠3s
        TimeUnit.SECONDS.sleep(3);
        System.out.println("线程1正在执行...");
    }

    public static synchronized void method2(){
        System.out.println("线程2正在执行...");
    }
}

//创建两个线程
public class Main {
    public static void main(String[] args) throws InterruptedException {
        //2个资源类对象
        Example example1=new Example();
        Example example2=new Example();

        //两个对象各创建并开启1个线程
        new Thread(()->{
            try {
                example1.method1();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();

        //第二个线程等待1s后创建
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            example2.method2();
        }).start();
    }
}

        先输出那个语句呢？

        运行结果：

        上面说到同一个类中所有静态的同步方法使用的锁对象都是这个类的Class对象，那么在这个案例中，不同的资源类对象对锁对象没有影响，线程1和线程2需要获取的锁是一样的。由于线程1先获取到锁，所以线程1先执行，线程2后执行。

  • 1个资源类对象，2个线程，1个静态同步方法+1个同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {
    //1个静态同步方法
    public static synchronized void method1() throws InterruptedException {
        //先休眠3s
        TimeUnit.SECONDS.sleep(3);
        System.out.println("线程1正在执行...");
    }

    //1个同步方法
    public synchronized void method2(){
        System.out.println("线程2正在执行...");
    }
}

//创建两个线程
public class Main {
    public static void main(String[] args) throws InterruptedException {
        //1个资源类对象
        Example example=new Example();

        //创建并开启2个线程
        new Thread(()->{
            try {
                example.method1();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();

        //第二个线程等待1s后创建
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            example.method2();
        }).start();
    }
}

        先输出那个语句呢？

        运行结果：

        对于线程1，静态方法的锁对象是Example.class；对于线程2，非静态同步方法的锁对象是方法调用者，即example，所以两个线程需要获取的锁是不同的，那么线程2就会在线程1休眠的时间里先执行完。

  • 2个资源类对象分别开启1个线程，1个静态同步方法+1个同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {
    //1个静态同步方法
    public static synchronized void method1() throws InterruptedException {
        //先休眠3s
        TimeUnit.SECONDS.sleep(3);
        System.out.println("线程1正在执行...");
    }

    //1个同步方法
    public synchronized void method2(){
        System.out.println("线程2正在执行...");
    }
}

//创建两个线程
public class Main {
    public static void main(String[] args) throws InterruptedException {
        //2个资源类对象
        Example example1=new Example();
        Example example2=new Example();

        //2个对象各创建并开启1个线程
        new Thread(()->{
            try {
                example1.method1();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();

        //第二个线程等待1s后创建
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            example2.method2();
        }).start();
    }
}

        先输出那个语句呢？

        运行结果：

          对于线程1，静态方法的锁对象是Example.class；对于线程2，非静态同步方法的锁对象是方法调用者，即example2，所以两个线程需要获取的锁是不同的，那么线程2就会在线程1休眠的时间里先执行完。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/536207.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

(2022级）成都工业学院数据库原理及应用实验三：数据定义语言DDL

(2022级）成都工业学院数据库原理及应用实验三：数据定义语言DDL

唉，用爱发电连赞都没几个，博主感觉没有动力了 想要完整版的sql文件的同学们，点赞评论截图，发送到2923612607qq,com，我就会把sql文件以及如何导入sql文件到navicat的使用教程发给你的 基本上是无脑教程了，…
阅读更多...
Banana Pi BPI-M7 RK3588开发板运行RKLLM软件堆AI大模型部署

Banana Pi BPI-M7 RK3588开发板运行RKLLM软件堆AI大模型部署

关于Banana Pi BPI-M7 Banana Pi BPI-M7 采用Rockchip RK3588，板载8/16/32G RAM内存和 64/128G eMMC存储，支持无线wifi6和蓝牙5.2。2x2.5G网络端口，1个HDMIout标准 输出口，2x USB3.0，2xTYPE-C，2x MIPI CSI…
阅读更多...
Day96：云上攻防-云原生篇Docker安全系统内核版本漏洞CDK自动利用容器逃逸

Day96：云上攻防-云原生篇Docker安全系统内核版本漏洞CDK自动利用容器逃逸

目录 云原生-Docker安全-容器逃逸&系统内核漏洞 云原生-Docker安全-容器逃逸&docker版本漏洞 CVE-2019-5736 runC容器逃逸(需要管理员配合触发) CVE-2020-15257 containerd逃逸(启动容器时有前提参数) 云原生-Docker安全-容器逃逸&CDK自动化 知识点&#xff1…
阅读更多...
Vue3基础语法

Vue3基础语法

在这个章节中&#xff0c;简单的看下Vue3的基础语法&#xff0c;有了这些基础后&#xff0c;对写vue3单页也就没有什么问题了。 模板语法 在写html时&#xff0c;我们希望在某个节点绑定一个动态值时&#xff0c;是使用dom操作执行的&#xff0c;如下&#xff1a; <!DOCT…
阅读更多...
（Java）数据结构——排序（第一节）堆排序+PTA L2-012 关于堆的判断

（Java）数据结构——排序（第一节）堆排序+PTA L2-012 关于堆的判断

前言 本博客是博主用于复习数据结构以及算法的博客&#xff0c;如果疏忽出现错误&#xff0c;还望各位指正。 堆排序&#xff08;Heap Sort&#xff09;概念 堆排序是一种基于堆数据结构的排序算法&#xff0c;其核心思想是将待排序的序列构建成一个最大堆&#xff08;或最小…
阅读更多...
大模型+交通治理，高德地图“评诊治”系统迎来全新升级

大模型+交通治理，高德地图“评诊治”系统迎来全新升级

近日&#xff0c;由中国道路交通安全协会主办的第十四届中国国际道路交通安全产品博览会暨公安交警警用装备展(以下简称交博会)在厦门国际会展中心开幕&#xff0c;会上高德地图发布了全新升级的城市交通“评诊治”智能决策SaaS系统&#xff0c;以助力城市交通的可持续、精细化…
阅读更多...
spring boot 集成rocketMq + 基本使用

spring boot 集成rocketMq + 基本使用

1. RocketMq基本概念 1. NameServer 每个NameServer结点之间是相互独立&#xff0c;彼此没有任何信息交互 启动NameServer。NameServer启动后监听端口&#xff0c;等待Broker、Producer、Consumer连接&#xff0c; 相当于一个路由控制中心。主要是用来保存topic路由信息&#…
阅读更多...
知识图谱与人工智能：携手共进

知识图谱与人工智能：携手共进

知识图谱与人工智能&#xff1a;携手共进 一、引言&#xff1a;知识图谱与人工智能的融合 在这个数据驱动的时代&#xff0c;知识图谱与人工智能&#xff08;AI&#xff09;之间的融合不仅是技术发展的必然趋势&#xff0c;也是推动各行各业创新的关键。知识图谱&#xff0c;作…
阅读更多...
windows下pycharm中配置conda虚拟环境

windows下pycharm中配置conda虚拟环境

目录 一&#xff1a;背景 二&#xff1a;安装conda环境 三&#xff1a;pycharm配置环境 四&#xff1a;注意问题 一&#xff1a;背景 在使用python的过程中&#xff0c;我们可能需要在一个windows环境中创建多个版本的python和安装不同的库去做一些开发任务。 使用conda&a…
阅读更多...
TQ15EG开发板教程：在MPSOC上运行ADRV9371

TQ15EG开发板教程：在MPSOC上运行ADRV9371

首先需要在github上下载两个文件&#xff0c;本例程用到的文件以及最终文件我都会放在网盘里面&#xff0c; 地址放在本文最后。首先在github搜索hdl选择第一个&#xff0c;如下图所示 GitHub网址&#xff1a;https://github.com/analogdevicesinc/hdl/releases 点击releases…
阅读更多...
Docker入门实战教程

Docker入门实战教程

文章目录 Docker引擎的安装Docker比vm虚拟机快 Docker常用命令帮助启动类命令镜像命令docker imagesdocker searchdocker pulldocker system dfdocker rmi 容器命令redis前台交互式启动redis后台守护式启动Nginx容器运行ubuntu交互式运行tomcat交互式运行对外暴露访问端口 Dock…
阅读更多...
Java基础07--多线程-网络编程-Java高级

Java基础07--多线程-网络编程-Java高级

一、多线程 1.认识多线程 ①线程 ②多线程 2.创建线程方式 ①方式一&#xff1a;继承Thread类 1.让子类继承Thread线程类 2.重写run方法&#xff0c;就是这个线程执行会执行的操作。 3.创建继承Thread的子类对象就代表一个线程 4.启动线程:.start()-自动执行run方法 注意&am…
阅读更多...
绝地求生：PUBG×杜卡迪联名上线！参与投稿评论赢取精美好礼

绝地求生：PUBG×杜卡迪联名上线！参与投稿评论赢取精美好礼

PUBG杜卡迪联名活动游戏内现已正式上线&#xff01;我们诚邀与您一起在开拓未知战场和书写新历史的过程中&#xff0c;与杜卡迪一同实现您的极速梦想&#xff01; 在本次的杜卡迪工坊中&#xff0c;更是包含了具备标志性红色在内的6种颜色供您自由选择&#xff0c;一起自由驰骋…
阅读更多...
创作一首音乐需要多长时间？网易云音乐内测AI音乐生成工具『网易天音』

创作一首音乐需要多长时间？网易云音乐内测AI音乐生成工具『网易天音』

大家好&#xff0c;我是木易&#xff0c;一个持续关注AI领域的互联网技术产品经理&#xff0c;国内Top2本科&#xff0c;美国Top10 CS研究生&#xff0c;MBA。我坚信AI是普通人变强的“外挂”&#xff0c;所以创建了“AI信息Gap”这个公众号&#xff0c;专注于分享AI全维度知识…
阅读更多...
视频基础学习五——视频编码基础二（编码参数帧、GOP、码率等）

视频基础学习五——视频编码基础二（编码参数帧、GOP、码率等）

系列文章目录 视频基础学习一——色立体、三原色以及像素 视频基础学习二——图像深度与格式&#xff08;RGB与YUV&#xff09; 视频基础学习三——视频帧率、码率与分辨率 视频基础学习四——视频编码基础一&#xff08;冗余信息&#xff09; 视频基础学习五——视频编码基础…
阅读更多...
KKVIEW远程远程访问家里电脑

KKVIEW远程远程访问家里电脑

远程访问家里电脑&#xff1a;简易指南与价值所在 在数字化时代&#xff0c;电脑已成为我们日常生活和工作中不可或缺的工具。有时&#xff0c;我们可能在外出时急需访问家中电脑里的某个文件或应用&#xff0c;这时&#xff0c;远程访问家里电脑就显得尤为重要。本文将简要介…
阅读更多...
SQLite---调试提示（十九）

SQLite---调试提示（十九）

返回&#xff1a;SQLite—系列文章目录 上一篇:SQLite Android 绑定&#xff08;十八&#xff09; 下一篇&#xff1a;从 SQLite 3.4.2 迁移到 3.5.0&#xff08;二十&#xff09; ​ 以下是 SQLite 开发人员跟踪、检查和了解 核心 SQLite 库。 这些技术旨在帮助理解 核…
阅读更多...
从 SQLite 3.5.9 迁移到 3.6.0（二十一）

从 SQLite 3.5.9 迁移到 3.6.0（二十一）

返回&#xff1a;SQLite—系列文章目录 上一篇&#xff1a;从 SQLite 3.4.2 迁移到 3.5.0&#xff08;二十&#xff09; 下一篇&#xff1a;SQLite—系列文章目录 ​SQLite 版本 3.6.0 &#xff08;2008-07-16&#xff09; 包含许多更改。按照惯例 SQLite项目&#xff…
阅读更多...
中移物联网 OneOS 操作系统环境搭建和工程创建

中移物联网 OneOS 操作系统环境搭建和工程创建

一、官网 OneOS Lite是中国移动针对物联网领域推出的轻量级操作系统&#xff0c;具有可裁剪、跨平台、低功耗、高安全等特点&#xff0c;支持ARM Cortex-A和 Cortex-M、MIPS、RISC-V等主流芯片架构&#xff0c;兼容POSIX、CMSIS等标准接口&#xff0c;支持Javascript、MicroPyt…
阅读更多...
Ubuntu下配置Android NDK环境

Ubuntu下配置Android NDK环境

Android-NDK的下载 下载Android-NDK wget -c http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin 执行bin文件&#xff08;即解压&#xff09; ./android-ndk-r10c-linux-x86_64.bin Android-NDK的配置 要想使用Android-NDK&#xff0c;还需要进行环境变量…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站