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

已于 2024-04-12 11:53:57 修改
阅读量1k 收藏 33
点赞数 21
文章标签： java 多线程 锁对象 同步方法 静态同步方法
于 2024-04-12 00:09:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65568592/article/details/137658176
版权
  • 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休眠的时间里先执行完。

车到山前必有路529
关注
  • 21
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mysql事务两个表加锁顺序_事务机制和锁机制
weixin_42528191的博客
02-02 1070
事务的必要性为了避免出现数据不一致问题，需要在存储过程中引入事务的概念，将更新语句绑在一起，让它们成为一个”原子性”的操作：更新语句要么都执行，要么都不执行。一、关闭MySQL自动提交的方法1、显示关闭自动提交set autocommit=0;12、隐式关闭自动提交：(推荐)start transaction1一般推荐使用隐式的提交方式，因为不会修改到autocommit系统变量。二、关闭自动提交...
死锁之加锁顺序
weixin_40839342的博客
07-23 1404
package thread.test; import java.math.BigDecimal; import java.util.Currency; public abstract class Amount implements Comparable<Amount>{ public abstract BigDecimal getBalance(); public abs...
解决死锁问题-设置加锁顺序
Wengzhengcun的博客
02-19 3178
大部分死锁都是由于不恰当的加锁顺序造成的，例如，线程A持有lock1等待lock2，而线程B持有lock2等待lock1，解决办法是每个线程都以相同的顺序获取多个锁。 先看一个由于错误的加锁顺序导致的死锁： public class TransferMoneyDeadLock { public void transferMoney(Account fromAccount, Acco...
线程加锁关键字
qq_774952435的博客
03-27 1536
加锁关键字
基于多线程并发-多线程为什么要加锁
qq_43148810的博客
01-31 2071
多线程为什么要加锁 1、数据竞争（data race） 1）多个线程访问其共有的资源（堆、全局变量等），需要加锁（互斥锁、读写锁、递归锁等），否则可能存在寄存器和内存数据不一致。 **注意：**堆对象的创建分为分配内存、初始化、指针指向该内存，注意锁的细粒度。 2）线程私有资源无需加锁。 2、不同线程的子步骤有顺序关联性 即线程2中必须等线程1将变量a赋值为1才能对a做除法。 注意: 为条件变量(std::condition_variable)的使用场景。 2）代码顺序不等同程序执行顺序
让线程按顺序执行8种方法.doc
10-05
让线程按顺序执行8种方法 本文将介绍让线程按顺序执行的8种方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。 一、使用线程的join方法 join()是...
Java实现指定线程执行顺序的三种方式示例
08-26
在实际开发中，我们可以根据具体情况选择合适的方式来实现指定线程执行顺序。 Java语言中的多线程编程是非常复杂的，需要我们具备深入的了解和经验。只有当我们充分理解了多线程编程的原理和机制时，才能更好地...
对Python多线程读写文件加锁的实例详解
12-25
Python的多线程在io方面比单线程还是有优势，但是在多线程开发时，少不了对文件的读写操作。在管理多个线程对同一文件的读写操作时，就少不了文件锁了。 使用fcntl 在linux下，python的标准库有现成的文件锁，来自于...
C++开发：为什么多线程读写shared_ptr要加锁的详细介绍
09-05
本篇文章介绍了，在C++中为什么多线程读写shared_ptr要加锁的详细说明。需要的朋友参考下
C# 不使用Task实现的多线程顺序执行
06-19
多线程有很好的并发性即无序性，在某些特殊情况下需要用到多线程然而又要使其具备顺序性，这种时候就有了一个特殊的场景那就是多线程顺序执行，在现在VS2015中Task自带了顺序执行的方法，但在此之前的旧项目中如果...
多线程-线程状态和线程安全（加锁-synchronized 关键字）
最新发布
weixin_71841320的博客
01-21 1063
例如，一个线程在读取一个共享变量的同时，另一个线程正在修改该变量，这就可能导致读取到的数据是。（脏数据是指在并发环境下，一个线程正在修改某个共享变量的同时，另一个线程正在读取同一个变量的值，从而导致读取到的值不正确或者不符合预期。3.直接原因：上述多线程修改操作，本身不是“原子的”（原子性是指一个操作是不可中断的，在执行过程中不能被其他线程或事件打断，要么全部执行成功，要么全部不执行。在Java中，线程有几种不同的状态，可以通过Thread类的getState()方法获取线程的当前状态。
多线程——常见的锁策略
qq_66767167的博客
11-01 123
锁策略是一把，常见的锁策略有：①悲观锁&乐观锁 ②轻量级锁&重量级锁 ③自旋锁&挂起等待锁 ④互斥锁&读写锁⑤不可重入锁（死锁）&可重入锁（不死锁） ⑥公平锁&非公平锁。
线程并发——锁（超简单）
Linux驱动相关内容及Android开发
02-23 960
什么是互斥锁呢，我给大家举个例子，我们可以想象成是车站的座位，然后把线程比喻成一个人，你进车站候车的时候，你就要先找到没有人的座位，然后坐下去（表示你正在使用），这样其他的人（其他的线程）就无法再使用这个座位了，如果想要使用该座位就需要你站起来，别人才可以使用。并发：同时发生在生活中，可能会有多个执行单元，同时访问同一个资源。比如座位。使用锁（互斥锁）来保护资源互斥锁：一个时刻值允许一个执行单元访问共享资源1.定义并初始化一把锁2.访问共享资源前。
Java中的加锁和死锁
qq_51364262的博客
10-01 89
可以拿门禁卡,这时就会发生死锁.左图就是这种死锁情况,运行代码后发现结果啥也没打印,说明代码根本没有运行到两个System.out.println语句中.这时由于t1获取到locker1时t2也获取到了locker2(保安获取到了进公司大门的资格,小寰获取到了在公司里拿门禁卡的资格),但t1要再获取locker2和t2要再获取locker1时就会获取不到进入阻塞等待(保安要再获取门禁卡,小寰要再获取进公司大门的资格,这时两人就会在门口).
多线程与并发 - 常见的几种锁的实现方式
简单记录一下。
11-25 1万+
正如其名，它是指对数据修改时持保守态度，认为其他人也会修改数据。因此在操作数据时，会把数据锁住，直到操作完成。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。如果加锁的时间过长，其他用户长时间无法访问，影响程序的并发访问性，同时这样对数据库性能开销影响也很大，特别是长事务而言，这样的开销往往无法承受。使用悲观锁的时候，我们要注意锁的级别，MySQL innodb 在加锁时，只有明确的指定主键或（索引字段）才会使用 行锁；否则，会执行 表锁，将整个表锁住，此时性能会很差。
Java 多线程 | 常见的锁策略、synchronized中的锁优化机制
1226
04-04 4813
一、常见的锁策略 锁策略，和普通程序猿基本没啥关系，和 "实现锁” 的人才有关系的 这里所提到的锁策略，和 Java 本身没关系，适用于所有和 “锁” 相关的情况 1、乐观锁 vs 悲观锁 处理锁冲突的态度(原因) 悲观锁：预期锁冲突的概率很高 乐观锁：预期锁冲突的概率很低 乐观的态度：认为，下一波疫情即使来了，但是菜应该是能买到 (根据前两波疫情的经验)，就不必专门做特殊的准备 悲观的态度：认为，下一波疫情来了之后，可能就买不到菜，于是换一个大的冰箱，去超市定期屯一些米面油肉＋方便面＋矿泉水＋常用药…
JAVA如何在线程中加锁（四种方法）
热门推荐
weixin_43907440的博客
04-22 2万+
JAVA多线程锁 线程的生命周期 ​ 总共六种状态，可归结为五种，线程的最终是死亡，阻塞不是最终状态，只是一个临时状态。只有调用了start方法，线程才进入就绪阶段。 //新生 ​ NEW, //运行​ RUNNABLE, //阻塞​ BLOCKED, //等待，死死地等​ WAITING, //超时等待​ TIMED_WAITING, //终止​ ...
多线程时需要注意互斥锁的加锁顺序，防止死锁
weixin_43354152的博客
10-17 907
C/C++多线程编程，需要注意加锁顺序，防止出现死锁
等待synchronized加锁期间能否通过中断线程来取消阻塞？
07-15
在等待`synchronized`加锁期间，是无法通过中断线程来取消阻塞的。 当一个线程在等待获取某个对象的锁时，它会进入阻塞状态，也就是被挂起，直到获取到锁为止。在这个过程中，如果另一个线程调用了该线程的`interrupt()`方法进行中断，被中断的线程会抛出`InterruptedException`异常，但并不会取消它对锁的等待。 `synchronized`关键字在Java中是一种独占锁，只有一个线程可以获取到锁并执行同步代码块，其他线程需要等待。如果一个线程在等待锁的过程中被中断，它仍然会继续等待获取锁，而不会因为中断而取消阻塞。 要实现通过中断来取消阻塞，可以使用`Lock`接口及其实现类，如`ReentrantLock`，结合`Condition`来实现可中断的锁等待。`Condition`提供了`await()`和`signal()`等方法，可以在等待锁的过程中响应中断并取消阻塞。 总之，对于`synchronized`关键字，中断线程无法直接取消阻塞，而使用可中断的锁机制可以满足这个需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值