【JUC —— 04 8锁问题】

最新推荐文章于 2024-08-12 15:45:48 发布
最新推荐文章于 2024-08-12 15:45:48 发布
阅读量374 收藏 6
点赞数 5
分类专栏： JUC （java.util.concurrent） 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72328778/article/details/140335763
版权

"8锁问题"是一个经典的多线程问题，主要测试对Java中synchronized关键字的理解，以及线程同步和锁机制的掌握。这个问题通常涉及到8种不同的情况，通过不同的锁和调用顺序，来观察哪个线程会先执行。以下是对8种情况的详细解释和代码示例。

题目描述

假设有两个方法sendEmail和sendSMS，以及一个普通方法hello，我们会在不同的条件下调用它们，观察它们的执行顺序。

情况1：两个方法都加锁，两个线程分别调用这两个方法

结果：sendEmail先执行，然后sendSMS执行。因为两个方法都加了synchronized，且是同一个对象锁。

class Phone {
    public synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }

    public void hello() {
        System.out.println("hello");
    }
}

public class EightLocks {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "Thread1").start();

        new Thread(() -> {
            phone.sendSMS();
        }, "Thread2").start();
    }
}

情况2：一个方法加锁，另一个方法不加锁，两个线程分别调用这两个方法

结果：sendSMS和sendEmail的执行顺序不确定。因为sendSMS没有锁，不受sendEmail锁的影响。

class Phone {
    public synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

    public void sendSMS() {
        System.out.println("sendSMS");
    }
}

public class EightLocks {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "Thread1").start();

        new Thread(() -> {
            phone.sendSMS();
        }, "Thread2").start();
    }
}

情况3：两个方法都加锁，且是静态锁，两个线程分别调用这两个方法

结果：sendEmail先执行，然后sendSMS执行。静态同步方法使用的是类锁（Phone.class），两个线程互斥。

class Phone {
    public static synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

    public static synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

public class EightLocks {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            Phone.sendEmail();
        }, "Thread1").start();

        new Thread(() -> {
            Phone.sendSMS();
        }, "Thread2").start();
    }
}

情况4：一个静态同步方法，一个非静态同步方法，两个线程分别调用这两个方法

结果：sendEmail和sendSMS的执行顺序不确定。一个是类锁，一个是对象锁，不互斥。

class Phone {
    public static synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

    public static synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

public class EightLocks {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

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

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

情况5：两个静态同步方法，两个对象，两个线程分别调用这两个方法

结果：sendEmail先执行，然后sendSMS执行。静态同步方法使用的是类锁，不管多少个对象，锁都是同一个。

class Phone {
    public static synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

    public static synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

public class EightLocks {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

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

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

情况6：两个非静态同步方法，两个对象，两个线程分别调用这两个方法

结果：sendEmail和sendSMS的执行顺序不确定。两个对象有各自的锁，不互斥。

class Phone {
    public synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

    public synchronized void sendSMS() {
        System.out.println("sendSMS");
    }
}

public class EightLocks {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

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

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

情况7：一个非静态同步方法，一个非同步方法，两个对象，两个线程分别调用这两个方法

结果：sendSMS和sendEmail的执行顺序不确定。sendSMS没有锁，不受sendEmail锁的影响。

class Phone {
    public synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

    public void sendSMS() {
        System.out.println("sendSMS");
    }
}

public class EightLocks {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

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

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

情况8：一个静态同步方法，一个非同步方法，两个对象，两个线程分别调用这两个方法

结果：sendSMS和sendEmail的执行顺序不确定。一个是类锁，一个是对象锁，不互斥。

class Phone {
    public static synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

    public void sendSMS() {
        System.out.println("sendSMS");
    }
}

public class EightLocks {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

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

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

总结

synchronized锁的是方法的调用者（拥有者）

通过"8锁问题"可以深入理解Java中的锁机制和synchronized关键字的使用。不同的锁（类锁和对象锁），不同的调用顺序和条件（静态方法和非静态方法），会导致不同的执行结果。通过这些案例，可以更好地理解并发编程中的锁机制。

&liuy
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——JUC
12-29
- `AtomicInteger`、`AtomicLong`等原子类提供了一种在不使用锁的情况下实现线程安全的方式，通过底层的CAS（Compare and Swap）操作保证了原子性，适用于简单的原子更新操作。 5. **Future和Callable接口** - `...
这就是标题—— JUC.pdf
05-19
JUC是什么 线程 进程 / 线程 线程状态 wait / sleep 并发 / 并行 Lock 使用Lock锁 可重入锁 公平锁 / 非公平锁 Synchronized / Lock 线程通讯 wait()、notify()和notifyAll() 虚假唤醒 Condition 定制化通信 多线程...
JUC——读写锁
weixin_51020122的博客
05-07 421
什么是读写锁 现实中有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。 针对这种场景，JAVA 的并发包提供了读写锁 ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁。 线程进入读锁的前提条件： 没有其他线程的写锁 没有写请求, 或者
JUC——读写锁原理
shall_zhao的博客
05-02 653
t3 进入 sync.releaseShared(1) 中，调用 tryReleaseShared(1) 让计数减一，这回计数为零了，进入doReleaseShared() 将头节点从 -1 改为 0 并唤醒老二，即。😉 这次自己是老二，并且没有其他竞争，tryAcquire(1) 成功，修改头结点，流程结束。这时会走到写锁的 sync.release(1) 流程，调用 sync.tryRelease(1) 成功，变成下面的样子。下一个节点不是 shared 了，因此不会继续唤醒 t4 所在节点。
JUC——8锁问题
鹏鹏2077
01-16 891
当关键字用于方法或代码块时，它可以用来实现对象级别的锁和类级别的锁。当用于非静态方法时，锁对象是调用该方法的实例对象。即每个对象实例都有自己的锁。当用于代码块时，锁对象可以是任意的Java对象。通常情况下，我们使用某个共享资源作为锁对象。无论是方法级别的锁还是代码块级别的锁，同一时间只能有一个线程获得锁并执行同步代码，其他线程需要等待锁释放。当用于静态方法时，锁对象是当前方法所属的类对象（Class对象）。类级别锁是针对整个类的所有对象实例生效的，不同实例之间共享这个锁。
JUC —— Lock锁
weixin_46540606的博客
02-07 358
真正的多线程(公司)开发，不会去创建一个类，用该类去继承Thread类或实现Runnable接口，线程就是一个单独的资源类，没有任何附属的操作！ Synchronized传统锁 public class SynchronizedTest { public static void main(String[] args) { //创建资源类 Ticket ticket = new Ticket(); //函数式接口使用lambda表达式 n
JUC——ReadWriteLock读写锁
qq_44891295的博客
04-11 144
文章目录1：ReadWriteLock读写锁介绍2：ReadWriteLock读写锁演示 1：ReadWriteLock读写锁介绍 ReadWriteLock是JDK5中提供的读写分离锁。读写分离锁可以有效地帮助减少锁竞争，提升系统性能。用锁分离的机制来提升性能非常容易理解，比如线程A1、 A2. A3进行写操作，B1、B2、B3进行读操作，如果使用重入锁或者内部锁，从理论上说所有读之间、读与写之间、写和写之间都是串行操作。当B1进行读取时，B2、 B3 则需要等待锁。由于读操作并不对数据的完整性造成破坏，
JUC —— 各种锁的理解
weixin_46540606的博客
02-09 439
公平锁、非公平锁 公平锁：非常公平，不能插队，必须先来后到 非公平锁：可以插队 可重入锁 可重入锁（递归锁） 拿到了最外层的锁，就自动获得了里面的锁 public class 可重入锁 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(()->{ phone.call(); },"A").start();
JUC —— 读写锁
weixin_46540606的博客
02-08 70
ReadWriteLock ReadWriteLock维护一对关联的licks，一个用于只读操作，一个用于写入，read lock可以由多个阅读线程同时进行，write lock是独家的（可以被多个线程同时读，只能被一个线程写） public class ReadWriteLockTest { public static void main(String[] args) { Data data = new Data(); for (int i = 1; i <=
JUC详解3——8锁问题
qq_41510551的博客
10-24 208
JUC详解38锁问题1、标准情况，两个线程是先发消息还是，先打电话？ 先发消息再打电话3、添加一个普通方法，两个线程是先发消息，还是先发hello？4、两个qq（对象），两个同步方法，两个线程是先发消息还是，先打电话？5、增加2个静态同步方法,一个对象，两个线程是先发消息还是，先打电话？7如果此时再增加一个普通的synchronized方法，是哪个先执行？总结： 8锁问题 1、标准情况，两个线程是先发消息还是，先打电话？ 先发消息再打电话 import java.util.concurrent.TimeUn
JUC并发编程——锁
weixin_39555954的博客
12-30 615
锁
JUC代码演示 Java多线程并发
05-03
除了`synchronized`之外，Java还提供了更灵活的锁机制——`Lock`接口。`Lock`接口提供了比`synchronized`更强大的锁定机制，并且实现了更加精细的线程控制。 在示例中，使用了`ReentrantLock`类来实现自定义的锁： ...
JUC并发编程与源码分析视频课.zip
12-16
10. **源码分析**：通过对JUC库中部分关键类的源码分析，帮助学员深入理解并发工具的内部实现，提升问题排查和优化能力。 通过这门课程的学习，你将具备扎实的Java并发编程能力，能够设计出高效、稳定的并发程序，...
尚硅谷JUC百度云连接
02-15
Java提供了强大的工具包——Java并发工具包（JUC，Java Util Concurrency），来帮助开发者轻松实现并发编程。 #### 核心组件 JUC包中包含了许多重要的类和接口，用于支持高级的并发编程： 1. **线程池**：通过`...
（javaweb）请求响应postman
2301_79144798的博客
08-08 518
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 485
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 524
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
最新发布
supercool7的博客
08-12 790
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
monitor 锁 和 JUC 锁 的区别
04-26
monitor锁和JUC锁（Java Util Concurrent锁）是两种不同的锁机制。 1. monitor锁是Java中的内置锁，也称为synchronized锁。它是基于对象的，每个对象都有一个关联的monitor锁。在使用synchronized关键字时，会自动获取对象的monitor锁。monitor锁是独占锁，即同一时间只能有一个线程持有该锁。当一个线程持有monitor锁时，其他线程必须等待锁的释放才能获取锁。monitor锁是可重入锁，同一个线程可以多次获取同一个锁。 2. JUC锁是Java Util Concurrent库中提供的锁机制，包括ReentrantLock、ReadWriteLock等。与monitor锁不同，JUC锁是基于接口的，可以根据需要选择不同的锁实现。JUC锁提供了更多的功能和灵活性，例如可定时获取锁、可中断获取锁、公平锁等。JUC锁也是可重入锁，同一个线程可以多次获取同一个锁。 区别： - monitor锁是Java语言级别的锁机制，而JUC锁是基于Java Util Concurrent库的锁机制。 - monitor锁是基于对象的，每个对象都有一个关联的monitor锁；而JUC锁是基于接口的，可以根据需要选择不同的锁实现。 - JUC锁提供了更多的功能和灵活性，例如可定时获取锁、可中断获取锁、公平锁等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值