Java八锁现象

最新推荐文章于 2022-09-09 22:45:54 发布
最新推荐文章于 2022-09-09 22:45:54 发布
阅读量283 收藏
点赞数
分类专栏： Java 文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s17856147699/article/details/126598600
版权

文章目录

八锁现象

一、简介

  • synchronized 锁的对象是方法的调用者
  • 两个方法用的是同一个锁，谁先拿到谁执行
  • 普通的方法是用对象操作的（同步方法 对象）
  • static静态方法是用Class操作的（静态同步方法 Class）
  • new this 具体的一个手机
  • static Class 唯一的一个模板

八种情况：
两个同步方法，一个对象（发短信，打电话）
两个同步方法，一个对象，发短信延迟（发短信，打电话）
一个同步方法，一个普通方法，一个对象，同步方法延迟（打电话，发短信）
两个同步方法，两个对象，发短信延迟（打电话，发短信）
两个静态同步方法，一个对象，发短信延迟（发短信，打电话）
两个静态同步方法，两个对象，发短信延迟（发短信，打电话）
一个静态同步方法，一个普通同步方法，一个对象，静态同步方法延迟（打电话，发短信）
一个普通同步方法，一个静态同步方法，两个对象，静态同步方法延迟（打电话，发短信）

二、代码案例

1、案例1

package com.sgz.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 日期：2022/8/30 - 10:34
 * 需求：两个同步方法，一个对象（发短信，打电话）
 */
public class Lock01 {
    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 {

    // synchronized 锁的对象是方法的调用者
    // 两个方法用的是同一个锁，谁先拿到谁执行
    public synchronized void sendSms() {
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

2、案例2

package com.sgz.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 日期：2022/8/30 - 10:34
 * 需求：两个同步方法，一个对象，发短信延迟（发短信，打电话）
 */
public class Lock02 {
    public static void main(String[] args) {

        Phone2 phone = new Phone2();

        // 锁的存在
        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

class Phone2 {

    // synchronized 锁的对象是方法的调用者
    // 两个方法用的是同一个锁，谁先拿到谁执行
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

3、案例3

package com.sgz.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 日期：2022/8/30 - 10:34
 * 需求：一个同步方法，一个普通方法，一个对象，同步方法延迟（hello，发短信）
 */
public class Lock03 {
    public static void main(String[] args) {

        Phone3 phone = new Phone3();

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

class Phone3 {

    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    // 没有锁，不是同步方法，不受锁的影响
    public  void call() {
        System.out.println("打电话");
    }
}

4、案例4

package com.sgz.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 日期：2022/8/30 - 10:34
 * 需求：两个同步方法，两个对象，发短信延迟（打电话，发短信）
 */
public class Lock04 {
    public static void main(String[] args) {

        // 两个对象，两个调用者，两把锁，与时间无关
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

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

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

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

class Phone4 {

    // synchronized 锁的对象是方法的调用者
    // 两个方法用的是同一个锁，谁先拿到谁执行
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

5、案例5

package com.sgz.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 日期：2022/8/30 - 10:34
 * 需求：两个静态同步方法，一个对象，发短信延迟（发短信，打电话）
 */
public class Lock05 {
    public static void main(String[] args) {

        Phone5 phone = new Phone5();

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

class Phone5 {

    // static 静态方法
    // 类一加载就有了，锁的是Class
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call() {
        System.out.println("打电话");
    }
}

6、案例6

package com.sgz.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 日期：2022/8/30 - 10:34
 * 需求：两个静态同步方法，两个对象，发短信延迟（发短信，打电话）
 */
public class Lock06 {
    public static void main(String[] args) {

        // 两个对象的Class类模板只有一个，static，锁的是Class类Phone6
        Phone6 phone1 = new Phone6();
        Phone6 phone2 = new Phone6();

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

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

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

// Phone6 唯一的一个 Class 对象
class Phone6 {

    // static 静态方法
    // 类一加载就有了，锁的是Class
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call() {
        System.out.println("打电话");
    }
}

7、案例7

package com.sgz.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 日期：2022/8/30 - 10:34
 * 需求：一个静态同步方法，一个普通同步方法，一个对象，静态同步方法延迟（打电话，发短信）
 */
public class Lock07 {
    public static void main(String[] args) {

        Phone7 phone = new Phone7();

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

class Phone7 {

    //  静态同步方法，锁的是Class类模板
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    // 普通同步方法，锁的是调用者
    public synchronized void call() {
        System.out.println("打电话");
    }
}

8、案例8

package com.sgz.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 日期：2022/8/30 - 10:34
 * 需求：一个普通同步方法，一个静态同步方法，两个对象，静态同步方法延迟（打电话，发短信）
 */
public class Lock08 {
    public static void main(String[] args) {

        // 两个对象的Class类模板只有一个，static，锁的是Class类Phone6
        Phone8 phone1 = new Phone8();
        Phone8 phone2 = new Phone8();

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

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

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

class Phone8 {

    // static 静态方法
    // 类一加载就有了，锁的是Class
    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}
Shen-Childe
关注
专栏目录
java 红锁(Red-Locking)的实现原理？
java专栏
07-22 1429
虽然“红锁”不是一个标准术语，但通过这次探索，相信你对分布式锁的魔法已经有了深刻的理解。无论是在宝藏岛上，还是在复杂的分布式系统中，合理运用这些锁的原理和技巧，都能帮助我们构建更加健壮、协调一致的服务。希望这次旅行让你满载而归，成为分布式系统中的寻宝高手！🌟。
Java 八锁详解
NULL
11-23 863
1),标准访问,请问先打印 邮件 还是短信? /** synchronized 和 lock 一样我这里用的是 lock*/ class phone { Lock lock = new ReentrantLock(); void sendMAIL(){ lock.lock(); try { System.out.println("---------sendMAIL"); } catch (Exception e
Java的8锁现象
weixin_56018532的博客
09-09 666
Java的8锁现象
java的8锁现象
qq_45699784的博客
01-28 422
锁的8个现象我写了4个测试类，每个测试类里两个现象都是相似的！！！ /** * 8锁现象 * 1.先发短信还是先打电话？ 答：先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出 * 2.在发短信方法中加4秒延时，看先发短信还是先打电话？ 答：还是先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出，即使发短信方法卡着4秒但是锁还没有被释放 * */ public class TestLock1 { public
【Java并发编程】8、各种锁的概念
weixin_33713503的博客
03-04 139
持续更新中... 共享锁（S锁）：如果事务T对数据A加上共享锁后，则其他事务只能对A再加共享锁，不能加排他锁，直到已释放所有共享锁。获准共享锁的事务只能读数据，不能修改数据。 排他锁（X锁）：如果事务T对数据A加上排他锁后，则其他事务不能再对A加任任何类型的锁，直到在事务的末尾将资源上的锁释放为止。获准排他锁的事务既能读数据，又能修改数据。 linux 自旋锁: 当进程进入CPU运行时，就会给它的...
Java并发4——八锁现象
weixin_51818357的博客
07-25 169
Java并发之八锁现象 1.这么说吧，如果两个都是普通方法，那么就看谁先调用，一般先调用先执行 2.如果都是普通方法，但是有加延时，那么就延时少的先调用(因为时间是差不多同时调用，但是一个延时4秒再执行，一个延时2秒再执行，肯定2秒的先执行出来） 3.如果加锁的话，无延时，仍然是谁先调用谁执行 4.如果加锁加延时的话，延时不管，谁先调用谁执行，管它延不延时，反正没执行完不出来，这就是锁的作用 锁的是对象，没结束，锁不释放 （这里先后调用看的是 程序中先调用了哪个方法的线程） 5.两个对象，两把锁，不存在锁的
java 线程公平锁与非公平锁详解及实例代码
08-31
公平锁的优点在于它遵循“先来后到”的原则，避免了饥饿现象，即某些线程永远无法获取锁。 非公平锁则没有这样的限制，它允许线程尝试立即获取锁，即使在其他线程正在等待的情况下也是如此。这就是所谓的“插队”...
Java并发之嵌套管程锁死详解
08-28
Java并发之嵌套管程锁死详解 Java并发编程中，嵌套管程锁死是一个经常出现的问题，严重影响着系统的性能和稳定性。嵌套管程锁死是由多个线程竞争资源导致的死锁现象。 嵌套管程锁死的发生： 嵌套管程锁死的发生是...
Java线程公平锁和非公平锁的差异讲解
08-26
- 非公平锁提高了锁的获取效率，但可能导致某些线程长时间等待，甚至可能出现饥饿现象，即某些线程始终无法获得锁。 - 在高竞争环境下，非公平锁通常表现出更好的性能，因为它减少了线程上下文切换的次数。 - 在低...
Java 锁详解
ycfxhsw的博客
07-06 345
公平锁：是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。类似排队打饭，先来后到。非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照 FIFO 的规则从队列中取到自己。非公平锁，比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁的方式。
JAVA-8锁
CB_Beginner的博客
02-09 508
例子： package com.cb.demo.example; import java.util.concurrent.TimeUnit; class Phone { public static synchronized void sendEmail()throws Exception { //暂停一会4秒 try{TimeUnit.SECONDS.sleep(4);}catch(InterruptedException e){e.printStack
java8的锁
MXqihang的博客
04-17 732
java8锁 文章目录java8锁CAS算法 Compare And Swap 比较与交换自旋锁 VS 适应性自旋锁自旋锁unsafe自适应自旋锁无锁->偏向锁->轻量锁->重量锁无锁偏向锁轻量级锁重量级锁公平锁、非公平锁公平锁可重入锁、非可重入锁可重入锁非可重入锁共享锁、独享锁底部 同步资源上锁 锁住 ： 悲观锁 不锁住： 乐观锁 锁同步资源，线程状态 阻赛 不阻赛： 自旋锁、适应性自旋锁 多线程竞争同步资源的流行细节 不锁资源，多线程中只有一个修改成功，其他线程重试：无锁
8锁 现象
DaDaguai001的博客
07-01 401
以下都是为了更好的解释锁。 1 标准访问，先打印邮件还是先发送短信 解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。 class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Threa..
JavaSE之8锁现象线程彻底理解锁
weixin_46036165的博客
05-31 184
8锁现象线程彻底理解锁 利用8道题，搞定锁这个概念！ 1.问题一 package com.coding.lock8; import java.util.concurrent.TimeUnit; /* 1、标准的访问情况下，先执行 sendEmail 还是 sendSMS 答案：sendEmail 被 synchronized 修饰的方式，锁的对象是方法的调用者，所以说这里两个方法调用的对象是同一个 先调用的先执行！ */ public class LockDemo01 {
经典 8 锁问题
yage124的博客
05-15 362
示例代码 1、资源类 import java.util.concurrent.TimeUnit; public class Phone { // 此方法根据题目需要添加 static public synchronized void sendSMS() { // 使用 TimeUnit 工具类执行 sleep 方法，比 Thread.sleep(毫秒)， // 方便控制输入的时间单位 // 根据题目要求设置该方法的休眠时间 try { TimeUnit.SEC
java8多线程锁_java多线程 线程八锁
weixin_29184075的博客
02-13 82
packagecom.java.juc;/*** 题目：判断打印 "one" or "two"** 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two* 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two* 3.新增普通方法 getThreee 打印？// 先打印three 三秒后打印 one two* 4.两个普通同步...
java的8锁问题
toBeMN的博客
04-13 2665
正经学徒，佛系记录，不搞事情 8锁即8个关于锁执行顺序的问题 解决问题前，首先需要明白的是 synchronized 只会锁两样东西，一样是调用的对象，一样是Class 问题一：两个普通的锁方法，new一个对象调用，调用过程中间睡1秒，执行结果是什么 public class Test { public static void main(String[] args) thro...
Java源码学习之并发编程-锁-Java中8种锁机制
weixin_37627646的博客
07-14 801
​ 在ReentrantLock中包含了公平锁和非公平锁两种锁。 如果你用默认的构造函数来创建ReentrantLock对象，默认的锁策略就是非公平的。 ​ 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。 优点：所有的线程都能得到资源，不会饿死在队列中。 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。 公平锁图示： 图示1： ​ 咱们重新回到第一张图，就是线程1刚刚释放锁之后，线程2还没来得及重新加锁的那个状
java的八锁问题
qq_43662627的博客
08-18 303
java的锁有对象锁和类锁两种，但不同的锁在不同的场景下是不同的，区别在于 1.对于普通同步方法，锁是当前实例对象(this)。 2.对于静态同步方法，锁是当前类的Class对象。 3.对于同步方法块，锁是Synchonized括号里配置的对象 讨论到java的八锁问题，我们一般讨论的是java锁住了类还是对象，或者或者是静态方法块 同步方法块的讨论 package day2.八锁问题; import org.junit.Test; import java.util.concurrent.TimeUn
Java多线程饥饿现象的解决方案及代码示例
Java多线程饥饿现象通常发生在并发环境中，当一个线程长时间无法获取所需的系统资源（如CPU时间、锁或其他同步机制）时，其他线程也无法正常运行，导致效率低下或死锁。本文的核心知识点围绕着如何避免写线程被阻塞...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值