Java的8锁现象

于 2022-09-09 22:45:54 发布
阅读量469 收藏 2
点赞数
分类专栏： javaSE 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56018532/article/details/126789971
版权

目录

1、标准访问，请问先打印邮件还是短信？

import java.util.concurrent.TimeUnit;

public class Lock8Demo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(phone::sendEmail, "A").start();
        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(phone::sendSMS, "B").start();
    }
}

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

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

执行main方法，控制台打印信息如下：

sendEmail
sendSMS

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

2、邮件方法暂停4秒钟，请问先打印邮件还是短信？

import java.util.concurrent.TimeUnit;

public class Lock8Demo {

    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(phone::sendEmail, "A").start();
        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(phone::sendSMS, "B").start();
    }


}

class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

执行main方法，控制台打印信息如下：

sendEmail
sendSMS

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

3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？

import java.util.concurrent.TimeUnit;

public class Lock8Demo {

    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(phone::sendEmail, "A").start();

        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(phone::sendSMS, "B").start();
        
        new Thread(phone::hello, "C").start();
    }
}

class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

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

执行main方法，控制台打印信息如下：

Hello
sendEmail
sendSMS

结论：新增的方法没有被synchronized修饰，不是同步方法，不受锁的影响，所以不需要等待。其他线程共用了一把锁，所以还需要等待。

4、两部手机、请问先打印邮件还是短信？

import java.util.concurrent.TimeUnit;

public class Lock8Demo {

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

        new Thread(phone1::sendEmail, "A").start();

        TimeUnit.MILLISECONDS.sleep(200);

        new Thread(phone2::sendSMS, "B").start();
    }
}

class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

执行main方法，控制台打印信息如下：

sendSMS
sendEmail

结论：被synchronized修饰的方法，锁的对象是方法的调用者。因为用了两个对象调用各自的方法，所以两个方法的调用者不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？

import java.util.concurrent.TimeUnit;

public class Lock8Demo {

    public static void main(String[] args) throws InterruptedException {

        Phone phone1 = new Phone();

        new Thread(()->{
            try {
                phone1.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();

        TimeUnit.MILLISECONDS.sleep(200);

        new Thread(()->{
            try {
                phone1.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}

class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

执行main方法，控制台打印信息如下：

sendEmail
sendSMS

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。因为两个同步方法都被static修饰了，所以两个方法用的是同一个锁，后调用的方法需要等待先调用的方法。

6、两个静态同步方法，2部手机，请问先打印邮件还是短信？

package com.coffee;

import java.util.concurrent.TimeUnit;

public class Lock8Demo {

    public static void main(String[] args) throws InterruptedException {

        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(()->{
            try {
                phone1.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();

        TimeUnit.MILLISECONDS.sleep(200);

        new Thread(()->{
            try {
                phone2.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();

    }
}

class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

执行main方法，控制台打印信息如下：

sendEmail
sendSMS

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。因为两个同步方法都被static修饰了，即便用了两个不同的对象调用方法，两个方法用的还是同一个锁，后调用的方法需要等待先调用的方法。

7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？

import java.util.concurrent.TimeUnit;

public class Lock8Demo {

    public static void main(String[] args) throws InterruptedException {

        Phone phone = new Phone();

        new Thread(Phone::sendEmail, "A").start();

        TimeUnit.MILLISECONDS.sleep(200);

        new Thread(phone::sendSMS, "B").start();
    }
}

class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

执行main方法，控制台打印信息如下：

sendSMS
sendEmail

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。仅仅被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法锁的对象不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？

import java.util.concurrent.TimeUnit;

public class Lock8Demo {

    public static void main(String[] args) throws InterruptedException {

        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(()->{
            try {
                phone1.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();

        TimeUnit.MILLISECONDS.sleep(200);

        new Thread(()->{
            try {
                phone2.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}

class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

执行main方法，控制台打印信息如下：

sendSMS
sendEmail

结论：被synchronized和static修饰的方法，锁的对象是类的class对象。仅仅被synchronized修饰的方法，锁的对象是方法的调用者。即便是用同一个对象调用两个方法，锁的对象也不是同一个，所以两个方法用的不是同一个锁，后调用的方法不需要等待先调用的方法。

9、总结

  • 对于普通同步方法，锁的是当前实例对象
  • 对于静态同步方法，锁的是当前的Class对象。
  • 对于同步方法块，锁是synchronized括号里面的配置对象
david6969xin
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java8的锁
MXqihang的博客
04-17 715
java8锁 文章目录java8锁CAS算法 Compare And Swap 比较与交换自旋锁 VS 适应性自旋锁自旋锁unsafe自适应自旋锁无锁->偏向锁->轻量锁->重量锁无锁偏向锁轻量级锁重量级锁公平锁、非公平锁公平锁可重入锁、非可重入锁可重入锁非可重入锁共享锁、独享锁底部 同步资源上锁 锁住 ： 悲观锁 不锁住： 乐观锁 锁同步资源，线程状态 阻赛 不阻赛： 自旋锁、适应性自旋锁 多线程竞争同步资源的流行细节 不锁资源，多线程中只有一个修改成功，其他线程重试：无锁
多线程8锁问题
lesliewongjie
04-29 186
多线程8锁问题一： 标准访问，请问先打印邮件还是短信? Java的8锁问题链接 8锁即8个关于锁执行顺序的问题 问题一： 标准访问，请问先打印邮件还是短信?
Java并发之线程八锁
fyphome
01-30 1679
一、引入 先了解什么是synchronized 不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的），记住一点，synchronized不是锁住了方法，而是锁住了使用了该方法的类对象或者对象实例，如： 1. 锁住对象实例： class Test{ public synchronized void test() { } } //等价于 class Test{ public void test() { synchronized(th
java8 n l_Java 8 锁机制 - osc_l745c1nv的个人空间 - OSCHINA - 中文开源技术交流社区
weixin_29495899的博客
02-13 167
主要对Java 8 常用的锁如何使用进行分享一、synchronized(一)、用法:1.synchronized可以用在方法(包含静态方法),2.synchronized块void increment() {synchronized (this) {count += 1;}}(二)、原理:关键词:monitor1.synchronized修饰方法synchronized void increme...
Java八锁现象
s17856147699的博客
08-30 269
Java八锁现象
java锁机制详解.pdf
10-04
Java锁机制是多线程编程中的核心概念，用于控制对共享资源的并发访问，防止数据的不一致性。Java提供了多种锁机制，包括内置锁（也称为监视器锁）和显式锁。本文将详细解析Java锁机制及其应用。 1. **内置锁（监视...
Java并发之嵌套管程锁死详解
08-28
Java并发之嵌套管程锁死详解 Java并发编程中，嵌套管程锁死是一个经常出现的问题，严重影响着系统的性能和稳定性。嵌套管程锁死是由多个线程竞争资源导致的死锁现象。 嵌套管程锁死的发生： 嵌套管程锁死的发生是...
Java concurrency之公平锁(一)_动力节点Java学院整理
08-30
公平锁确保等待获取锁的线程按照到达的顺序被唤醒，而非公平锁则允许线程尝试直接获取锁，可能导致饥饿现象。 - **共享锁**：允许多个线程同时持有共享锁。如ReentrantReadWriteLock的读锁、CyclicBarrier、...
java 多线程饥饿现象的问题解决方法
08-30
以下是一个使用锁机制解决 Java 多线程饥饿现象的问题的实现代码： ```java package readerWriter; public class File { private String name; public File(String name) { this.name = name; } } package ...
java 线程公平锁与非公平锁详解及实例代码
08-31
公平锁的优点在于它遵循“先来后到”的原则，避免了饥饿现象，即某些线程永远无法获取锁。 非公平锁则没有这样的限制，它允许线程尝试立即获取锁，即使在其他线程正在等待的情况下也是如此。这就是所谓的“插队”...
java多线程详解，线程池原理，8种锁,java内存模型......
01-25
首先希望大家喜欢我制作的文档，如果文档中有什么误解的地方，望告诉一下，5分是也不多，是系统默认的，那么就5分咯，java多线程详解，线程池原理，8种锁,java内存模型......
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7986
深入理解JUC的8锁现象
java多线程之线程八锁案例
qq_42400763的博客
04-27 335
1.八锁现象 如何判断锁的是谁?永远的知道什么锁,锁到底锁的是谁? 深刻理解我们的锁! 1.标准情况下,两个线程先打印.是先发短信还是打电话? public class Teat01 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(()->...
Java实现经典八锁问题
05-08 525
🚀在 Loki的个人博客，阅读体验更佳 下面将通过经典的8锁问题，认清锁原理
JAVA-8锁
CB_Beginner的博客
02-09 493
例子： 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
java的8锁现象
qq_45699784的博客
01-28 408
锁的8个现象我写了4个测试类，每个测试类里两个现象都是相似的！！！ /** * 8锁现象 * 1.先发短信还是先打电话？ 答：先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出 * 2.在发短信方法中加4秒延时，看先发短信还是先打电话？ 答：还是先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出，即使发短信方法卡着4秒但是锁还没有被释放 * */ public class TestLock1 { public
Java 8无人谈及的八大功能
Just Do It ——张俊永
06-27 786
时间戳锁 一直以来，多线程代码是服务器开发人员的毒药（问问Oracle的Java语言架构师和并行开发大师Brian Goetz）。Java的核心库不断加入各种复杂的用法来减少访问共享资源时的线程等待时间。其中之一就是经典的读写锁（ReadWriteLock），它让你把代码分成两部分：需要互斥的写操作和不需要互斥的读操作。 表面上看起来很不错。问题是读写锁有可能是极慢的（最多10倍），这
Java多线程编程学习笔记之六：使用synchronized获取互斥锁的几点说明
810364804
12-08 283
转载请注明出处：http://blog.csdn.net/ns_code/article/details/17199201 在并发编程中，多线程同时并发访问的资源叫做临界资源，当多个线程同时访问对象并要求操作相同资源时，分割了原子操作就有可能出现数据的不一致或数据不完整的情况，为避免这种情况的发生，我们会采取同步机制，以确保在某一时刻，方法内只允许有一个线程。 采用synchron...
java的八锁问题
qq_43662627的博客
08-18 277
java的锁有对象锁和类锁两种，但不同的锁在不同的场景下是不同的，区别在于 1.对于普通同步方法，锁是当前实例对象(this)。 2.对于静态同步方法，锁是当前类的Class对象。 3.对于同步方法块，锁是Synchonized括号里配置的对象 讨论到java的八锁问题，我们一般讨论的是java锁住了类还是对象，或者或者是静态方法块 同步方法块的讨论 package day2.八锁问题; import org.junit.Test; import java.util.concurrent.TimeUn
Java为什么有死锁的现象
最新发布
05-17
Java中发生死锁的主要原因是多个线程在竞争同一组资源时，出现了相互等待的情况。当两个或多个线程都在等待对方释放资源时，它们就会相互阻塞，形成死锁。 例如，如果线程 A 持有资源 x 并正在等待资源 y，而线程 B 持有资源 y 并正在等待资源 x，则两个线程都无法继续执行，进入死锁状态。 避免死锁的常用方法包括： 1. 避免嵌套锁定：尽量避免在一个锁内部再次锁定其他资源。 2. 统一获取锁的顺序：所有线程都按照相同的顺序获取锁，可以避免死锁。 3. 设置超时时间：在获取锁时，可以设置一个超时时间，如果在规定时间内没有获取到锁，就放弃获取。 4. 使用可重入锁：可重入锁可以重复进入同一个锁，避免了死锁的可能性。 5. 使用并发包中的工具类：Java并发包中提供了一些工具类，如Semaphore和CountDownLatch，可以帮助我们更好地控制线程的并发执行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值