java8锁问题

最新推荐文章于 2024-08-17 10:02:14 发布
最新推荐文章于 2024-08-17 10:02:14 发布
阅读量222 收藏
点赞数
文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45664397/article/details/116948811
版权

经典八锁问题

1、synchronized标准访问

/**
 * @author alex tse
 * 8锁问题
 * 1、标准访问，先发短信还是先打电话
 */
public class test1 {
    public static void main(String[] args) {
        phone phone = new phone();
        new Thread(()->{
            phone.sendSMS();	//线程A执行发短信
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);		//休眠1s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();		//线程B执行打电话
        },"B").start();
    }
}

class phone{
    public synchronized void sendSMS(){
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

在这里插入图片描述

最终是A线程先执行，B线程后执行

结论一

被synchronized修饰的方法，锁的对象是方法的调用者（对象）。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行。

2、方法内休眠

/**
 * @author alex tse
 * 8锁问题
 * 1、标准访问，先发短信还是先打电话
 * 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
 */
public class test1 {
    public static void main(String[] args) {
        phone phone = new phone();
        new Thread(()->{
            phone.sendSMS();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class phone{
    public synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(4);	//休眠四秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

在这里插入图片描述

结论

被synchronized修饰的方法，锁的对象是方法的调用者（对象）。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行，第二个方法只有在第一个方法执行完释放锁之后才能执行。

3、增加普通方法

/**
 * @author alex tse
 * 8锁问题
 * 1、标准访问，先发短信还是先打电话
 * 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
 * 3、新增一个普通方法hello(),请问先打印邮件还是hello？
 */
public class test1 {
    public static void main(String[] args) {
        phone phone = new phone();
        new Thread(()->{
            phone.sendSMS();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            //phone.call();
            phone.hello();
        },"B").start();
    }
}
class phone{
    public synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

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

在这里插入图片描述

结论

普通方法没有被synchronized修饰，不是同步方法，不受锁的影响，不需要等待，其他同步方法需要等待。

4、两个对象

/**
 * @author alex tse
 * 8锁问题
 * 1、标准访问，先发短信还是先打电话
 * 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
 * 3、新增一个普通方法hello(),请问先打印邮件还是hello？
 * 4、两个生成的对象、请问先打印邮件还是短信？
 */
public class test1 {
    public static void main(String[] args) {
        phone phone1 = new phone();
        phone phone2 = new phone();
        new Thread(()->{
            phone1.sendSMS();	//phone1
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class phone{
    public synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

在这里插入图片描述

结论

两个对象，synchronized锁的对象是方法的调用者（对象），因为有两个对象所以有两把锁，两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

5、两个静态同步方法，一个对象

/**
 * @author alex tse
 * 8锁问题
 * 1、标准访问，先发短信还是先打电话
 * 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
 * 3、新增一个普通方法hello(),请问先打印邮件还是hello？
 * 4、两个生成的对象、请问先打印邮件还是短信？
 * 5、两个静态同步方法，同一个对象，请问先打印邮件还是短信？
 */
public class test1 {
    public static void main(String[] args) {
        phone phone = new phone();
        new Thread(()->{
            phone.sendSMS();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class phone{
    public static synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }

}

在这里插入图片描述

结论

被synchronized+static修饰的方法，锁的是类的class对象。两个方法都是静态方法，所以用的是同一个锁，先调用的方法先执行

6、两个静态同步方法，两个对象

/**
 * @author alex tse
 * 8锁问题
 * 1、标准访问，先发短信还是先打电话
 * 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
 * 3、新增一个普通方法hello(),请问先打印邮件还是hello？
 * 4、两个生成的对象、请问先打印邮件还是短信？
 * 5、两个静态同步方法，同一个对象，请问先打印邮件还是短信？
 * 6、两个静态同步方法，两个对象，请问先打印邮件还是短信？
 */
public class test1 {
    public static void main(String[] args) {
        phone phone1 = new phone();
        phone phone2 = new phone();
        new Thread(()->{
            phone1.sendSMS();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class phone{
    public static synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }

}

在这里插入图片描述

结论

synchronized+static锁的是类的class模板，类的class是唯一的，所以两个对象的静态方法都被一把锁锁住，先调用的先执行。

7、一个普通同步方法，一个静态同步方法，一个对象

/**
 * @author alex tse
 * 8锁问题
 * 1、标准访问，先发短信还是先打电话
 * 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
 * 3、新增一个普通方法hello(),请问先打印邮件还是hello？
 * 4、两个生成的对象、请问先打印邮件还是短信？
 * 5、两个静态同步方法，同一个对象，请问先打印邮件还是短信？
 * 6、两个静态同步方法，两个对象，请问先打印邮件还是短信？
 * 7、一个普通同步方法，一个静态同步方法，同一个对象，请问先打印邮件还是短信？
 */
public class test1 {
    public static void main(String[] args) {
        phone phone = new phone();
        new Thread(()->{
            phone.sendSMS();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class phone{
    public static synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

}

在这里插入图片描述

结论

synchronized+static锁的是类的class对象，synchronized所得是方法的调用者，所以两个方法不是被同一个锁锁住，后调用的方法不需要等待先调用的。

8、一个普通同步方法，一个静态同步方法，两个对象

/**
 * @author alex tse
 * 8锁问题
 * 1、标准访问，先发短信还是先打电话
 * 2、邮件方法暂停4秒钟，请问先打电话还是短信？
 * 3、新增一个普通方法hello(),请问先发短信还是hello？
 * 4、两个生成的对象、请问先打电话还是短信？
 * 5、两个静态同步方法，同一个对象，请问先打电话还是短信？
 * 6、两个静态同步方法，两个对象，请问先打电话还是短信？
 * 7、一个普通同步方法，一个静态同步方法，同一个对象，请问先打电话还是短信？
 * 8、一个普通同步方法，一个静态同步方法，两个对象，请问先打电话还是短信？
 */
public class test1 {
    public static void main(String[] args) {
        phone phone1 = new phone();
        phone phone2 = new phone();
        new Thread(()->{
            phone1.sendSMS();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class phone{
    public static synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

}

在这里插入图片描述

结论

synchronized+static修饰的是方法是锁住类的class对象，synchronized修饰的方法锁住的是方法的调用者，所以是两个不同的锁，后调用的方法不需要等待先调用的方法。

小结

一个对象里面如果有多个synchronized方法，某个时刻内，只要一个线程去调用其中一个synchronized方法了，其他的线程都要等待，换句话说，在某个时刻内，只能有唯一一个线程去访问这些synchronized方法，锁的是当前对象this，被锁定后，其他的线程都不能进入到当前对象的其他的synchronized方法；

加个普通方法后发现和同步锁无关，换成两个对象后，不是同一把锁，情况立刻变化

都换成静态同步方法后，情况又变化了。所有的非静态的同步方法用的都是同一把锁----实例对象本身

synchronized实现同步的基础：java中的每一个对象都可以作为锁

具体的表现为以下三种形式：

对于普通同步方法，锁的是当前实例对象

对于静态同步方法，锁的是当前的Class对象。

对于同步方法块，锁是synchronized括号里面的配置对象

当一个线程试图访问同步代码块时，他首先必须得到锁，退出或者是抛出异常时必须释放锁，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可以是别的实例对象非非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以必须等待该实例对象已经获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁----类对象本身

现和同步锁无关，换成两个对象后，不是同一把锁，情况立刻变化

都换成静态同步方法后，情况又变化了。所有的非静态的同步方法用的都是同一把锁----实例对象本身

synchronized实现同步的基础：java中的每一个对象都可以作为锁

具体的表现为以下三种形式：

对于普通同步方法，锁的是当前实例对象

对于静态同步方法，锁的是当前的Class对象。

对于同步方法块，锁是synchronized括号里面的配置对象

当一个线程试图访问同步代码块时，他首先必须得到锁，退出或者是抛出异常时必须释放锁，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可以是别的实例对象非非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以必须等待该实例对象已经获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁----类对象本身

这两把锁的是两个不同的对象，所以静态的同步方法与非静态的同步方法之间是不会有竞争条件的，但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要他们用一个的是同一个类的实例对象。

AlexTseGDUT
关注
java的八锁问题
qq_43662627的博客
08-18 306
java的锁有对象锁和类锁两种，但不同的锁在不同的场景下是不同的，区别在于 1.对于普通同步方法，锁是当前实例对象(this)。 2.对于静态同步方法，锁是当前类的Class对象。 3.对于同步方法块，锁是Synchonized括号里配置的对象 讨论到java的八锁问题，我们一般讨论的是java锁住了类还是对象，或者或者是静态方法块 同步方法块的讨论 package day2.八锁问题; import org.junit.Test; import java.util.concurrent.TimeUn
java8看不到源码-dlock:一种有效可靠的分布式锁
06-04
java8 看不到源码DLock - 分布式锁 DLock 是 Java 实现的、有效且可靠的分布式锁。 它使用Redis存储锁对象，通过[Lua](脚本)对锁进行原子操作。基于Redis的过期机制，DLock实现了锁[租借](以保证释放。为了提供高...
java的8锁问题
toBeMN的博客
04-13 2669
正经学徒，佛系记录，不搞事情 8锁即8个关于锁执行顺序的问题 解决问题前，首先需要明白的是 synchronized 只会锁两样东西，一样是调用的对象，一样是Class 问题一：两个普通的锁方法，new一个对象调用，调用过程中间睡1秒，执行结果是什么 public class Test { public static void main(String[] args) thro...
Java并发编程 - 8锁的现象
最新发布
qq_33240556的博客
08-17 689
在Java并发编程中，“8锁的现象”并不是一个标准术语或概念，可能是对某些特定现象的概括或简称。不过，根据上下文，我们可以推测这个问题可能是指在Java并发编程中与锁相关的八个典型现象或问题。@Contended。
Java实现经典八锁问题
05-08 558
🚀在 Loki的个人博客，阅读体验更佳 下面将通过经典的8锁问题，认清锁原理
Java多线程JUC8锁问题
qq_41898181的博客
09-25 325
一、线程的8锁问题 前提：8锁问题的讨论是建立在使用Thread.sleep(200)后，假设A线程先于B线程被CPU调度的前提下。 1.1 标准访问，请问先打印邮件还是短信？ class Phone{ public synchronized void sendEmail() throws Exception{ System.out.println("----------sendEmail"); } public synchronized void sendS
java8 n l_Java 8 锁机制 - osc_l745c1nv的个人空间 - OSCHINA - 中文开源技术交流社区
weixin_29495899的博客
02-13 181
主要对Java 8 常用的锁如何使用进行分享一、synchronized(一)、用法:1.synchronized可以用在方法(包含静态方法),2.synchronized块void increment() {synchronized (this) {count += 1;}}(二)、原理:关键词:monitor1.synchronized修饰方法synchronized void increme...
Java synchronized锁升级jol过程详解
08-19
锁对象头（markword部分，8字节）使用不同的状态进行表示。在64位虚拟机的markword中，状态位的分布如下所示： * 无锁状态：最后3位为001 * 偏向锁：最后3位为101 * 轻量级锁：最后3位为001 * 重量级锁：最后3位为...
java-syn.zip_Java syn_Java syn锁_java同步锁syn_java锁 syn_syn同步事务锁
09-14
总结来说，Java中的同步锁是多线程编程中的核心概念，通过合理的同步机制，开发者可以有效地管理共享资源，防止数据不一致性和线程安全问题。理解并熟练运用这些机制，对于编写高效、可靠的多线程程序至关重要。
深入理解java内置锁(synchronized)和显式锁(ReentrantLock)
08-28
深入理解Java内置锁(synchronized)和显式锁(ReentrantLock) Java中有两种锁机制：内置锁（synchronized）和显式锁（ReentrantLock）。...8. 内置锁和显式锁都是Java中用于同步的机制，但是它们有着不同的优点和缺点。
Java中的锁分类的详细介绍
08-29
Java 中的锁分类可以分为多种类型，包括公平锁、非公平锁、可重入锁、独享锁、共享锁、互斥锁、读写锁、乐观锁、悲观锁、分段锁、偏向锁、轻量级锁、重量级锁、自旋锁等。这些锁的分类并不是指锁的状态，有的指锁的...
java8的锁
MXqihang的博客
04-17 739
java8锁 文章目录java8锁CAS算法 Compare And Swap 比较与交换自旋锁 VS 适应性自旋锁自旋锁unsafe自适应自旋锁无锁->偏向锁->轻量锁->重量锁无锁偏向锁轻量级锁重量级锁公平锁、非公平锁公平锁可重入锁、非可重入锁可重入锁非可重入锁共享锁、独享锁底部 同步资源上锁 锁住 ： 悲观锁 不锁住： 乐观锁 锁同步资源，线程状态 阻赛 不阻赛： 自旋锁、适应性自旋锁 多线程竞争同步资源的流行细节 不锁资源，多线程中只有一个修改成功，其他线程重试：无锁
8锁问题
weixin_43912697的博客
03-01 114
8锁问题：关于锁的8个问题 public class demo01 { public static void main(String[] args) { Phone1 phone = new Phone1(); new Thread(()->{ phone.send(); },"A").start(); // 延时2秒 try { TimeUnit.SECONDS
Java的8锁现象
weixin_56018532的博客
09-09 668
Java的8锁现象
【Java并发编程] 线程八锁问题
小新的博客
01-12 1300
生活总会有惊喜，谁知道下一秒会发生什么呢
经典 8 锁问题
yage124的博客
05-15 364
示例代码 1、资源类 import java.util.concurrent.TimeUnit; public class Phone { // 此方法根据题目需要添加 static public synchronized void sendSMS() { // 使用 TimeUnit 工具类执行 sleep 方法，比 Thread.sleep(毫秒)， // 方便控制输入的时间单位 // 根据题目要求设置该方法的休眠时间 try { TimeUnit.SEC
Java 8 并发：同步和锁
weixin_34284188的博客
12-24 132
原文地址： Java 8 Concurrency Tutorial: Synchronization and Locks 为了简单起见，本教程的示例代码使用了在这里定义的两个辅助方法，sleep(seconds) 和 stop(executor) Synchronized 当我们编写多线程代码访问可共享的变量时需要特别注意，下面是一个多...
Java并发之线程八锁
fyphome
01-30 1720
一、引入 先了解什么是synchronized 不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的），记住一点，synchronized不是锁住了方法，而是锁住了使用了该方法的类对象或者对象实例，如： 1. 锁住对象实例： class Test{ public synchronized void test() { } } //等价于 class Test{ public void test() { synchronized(th
JAVA并发编程的8锁问题（synchronized，static synchronized和普通方法调用）
Dream_6666的博客
08-22 247
通过示例说明：（注意代码中的延时问题） 情况1、2 /* 8锁，就是锁的8个问题 1.标准情况下（只有上面的延迟），两个线程先打印发短信还是打电话? 1.发短信 2.打电话 （锁的是同一个对象即方法的调用者，所以是并发） 2.sendSms延迟4秒，两个线程先打印发短信还是打电话? 1.发短信 2.打电话 （锁的是同一个对象即方法的调用者，所以是并发），synchronized 锁的对象是方法的调用者！ */ public class Test1 {
Java Synchronized锁机制解析
8. **显式锁**： - Java 5 引入了 `java.util.concurrent.locks` 包，提供了 `ReentrantLock`、`ReadWriteLock` 等显式锁，相比内置锁提供了更多的控制和灵活性，如可中断锁、定时锁等待等功能。 9. **线程安全**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值