五.锁的8种情况

最新推荐文章于 2021-11-17 13:51:05 发布
最新推荐文章于 2021-11-17 13:51:05 发布
阅读量191 收藏 2
点赞数
分类专栏： JUC 文章标签： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42480780/article/details/116235539
版权

多线程8锁

  1. 标准访问，先打印短信还是邮件
  2. 停4秒在短信方法内，先打印短信还是邮件
  3. 普通的hello方法，是先打短信还是hello
  4. 现在有两部手机，先打印短信还是邮件
  5. 两个静态同步方法，1部手机，先打印短信还是邮件
  6. 两个静态同步方法，2部手机，先打印短信还是邮件
  7. 1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件
  8. 1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件

1.标准访问，先打印短信还是邮件

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

public class Lock_8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep(100); // 确保A进程先启动
        
        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
}

//输出  先打印Email
----sendEmail
----sendSMS

2.停4秒在短信方法内，先打印短信还是邮件

class Phone{
    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(4);  //停四秒钟
        System.out.println("----sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("----sendSMS");
    }
}

public class Lock_8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep(100); // 确保A进程先启动

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

//输出  先打印Email
----sendEmail
----sendSMS

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

3.新增普通的hello方法，是先打短信还是hello

class Phone{
    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(4);  //停四秒钟
        System.out.println("----sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("----sendSMS");
    }
    public void hello(){
        System.out.println("----hello");
    }
}

public class Lock_8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep(100); // 确保A进程先启动

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

//输出 先打印hello
----hello
----sendEmail

加个普通方法后发现和同步锁无关

4.现在有两部手机，先打印短信还是邮件

class Phone{
    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(4);  //停四秒钟
        System.out.println("----sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("----sendSMS");
    }
}

public class Lock_8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep(100); // 确保A进程先启动

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

//输出 先打印SMS
----sendSMS
----sendEmail

换成两个对象后，不是同一把锁了，情况立刻变化。

5.两个静态同步方法，1部手机，先打印短信还是邮件

class Phone{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(4);  //停四秒钟
        System.out.println("----sendEmail");
    }
    public static synchronized void sendSMS() throws Exception{
        System.out.println("----sendSMS");
    }
}

public class Lock_8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep(100); // 确保A进程先启动

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

//输出  先输出Email
----sendEmail
----sendSMS

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

class Phone{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(4);  //停四秒钟
        System.out.println("----sendEmail");
    }
    public static synchronized void sendSMS() throws Exception{
        System.out.println("----sendSMS");
    }
}

public class Lock_8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep(100); // 确保A进程先启动

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

//输出  先输出Email
----sendEmail
----sendSMS

synchronized实现同步的基础：Java中的每一个对象都可以作为锁。
具体表现为以下3种形式:
对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的Class对象。
对于同步方法块，锁是Synchonized括号里配置的对象

7. 1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件

class Phone{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(4);  //停四秒钟
        System.out.println("----sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("----sendSMS");
    }
}

public class Lock_8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep(100); // 确保A进程先启动

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

//输出 先输出SMS
----sendSMS
----sendEmail

8. 1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件

class Phone{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(4);  //停四秒钟
        System.out.println("----sendEmail");
    }
    public synchronized void sendSMS() throws Exception{
        System.out.println("----sendSMS");
    }
}

public class Lock_8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep(100); // 确保A进程先启动

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

//输出 先输出SMS
----sendSMS
----sendEmail
  1. 当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。
  2. 也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
  3. 所有的静态同步方法用的也是同一把锁——类对象本身。
  4. 静态同步方法与非静态同步方法的两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！
一朝红日出
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows密码锁.zip
08-27
1. 长度：至少8个字符。 2. 复杂性：包含大写字母、小写字母、数字和特殊字符的组合。 3. 重复字符限制：不允许连续或重复的字符。 三、修改Windows密码 若需更改密码，只需重复上述设置密码的步骤，但选择“更改...
JAVA程序设计基础8ppt课件.ppt
最新发布
11-23
线程的生命周期包括五个状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Terminated）。新建状态是指线程刚刚创建还未开始执行；就绪状态是线程准备运行，但等待CPU分配时间片；运行...
八锁现象理解锁
qq_46027706的博客
01-20 274
接下来以代码为例来理解锁的八种情况： TimeUtils工具类:API提供的常用工具类，时间处理。 1、以下代码是先发短信还是先打电话？ package com.yy; import java.util.concurrent.TimeUnit; public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); new Th
juc并发07锁的八种情况
weixin_42537314的博客
09-08 120
8种锁: 1.标准访问，先打印短信还是邮件 2.停留4秒在短信方法内，先打印短信还是邮件 3.新增普通的hello方法，先是打短信还是hello 4.现在有两部手机，先打印短信还是邮件 5.两个静态同步方法，1部手机，先打印短信还是邮件 6.两个静态同步方法，2部手机，先打印短信还是邮件 7.1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件 8.1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件 一、标准访问，先打印短信还是邮件 资源类 创建线程操作方法 结果，因为当前
线程锁的常见几种情况
百知_zmj的博客
04-23 270
线程锁的几种情况 两个普通同步方法，两个线程： public class TestSynchronized { public static void main(String[] args) throws InterruptedException { final Number number = new Number(); //启动一个线程 new Thread(new Runn...
深入学习并发编程中的synchronized
qq_43183527的博客
11-17 643
run()和start()的区别
Java并发--InterruptedException机制
06-03 2万+
原创声明：本文系作者原创，谢绝个人、媒体、公众号或网站未经授权转载，违者追究其法律责任。近期重新学习juc中的ReentrantLocklock类源码，虽然之前有相当长时间从事IM编发编程，但每次回顾IM设计，都会有新的收获。这次从中重新收获java中断类InterruptedException的理解。java中断响应是描述当一个线程或方法A处于运行、阻塞或死锁状态时，外界(通常指其他线程、系统I...
电厂招聘电气试题五.doc
10-07
当发生这种情况时，装置应该B) 发出信号，断开保护电源，确保保护系统的正确运行。 2. 距离保护第Ⅰ段通常设计为保护线路全长的约80％，即C) 80％，这是为了快速切除故障，保护主设备。 3. 变压器重瓦斯保护动作...
如何解决informix数据库锁表问题.doc
05-05
可以通过 onstat –k 命令来查看当前的锁表情况。输出结果中，wtlist 项表示当前锁表的线程，owner 项表示锁表的所有者，lklist 项表示锁表的类型。 例如： ``` Locks address wtlist owner lklist type tblsnum ...
基于网络安全的变电站智能五防解锁钥匙管理系统的开发.pdf
09-19
本文主要介绍了一种基于网络安全的变电站智能五防解锁钥匙管理系统的开发。该系统旨在解决目前变电站五防解锁钥匙使用和管理效率低下的问题，提高五防解锁钥匙的使用效率，规范现场五防解锁钥匙的审批和实施，提升...
Synchronized关键字及锁升级
weixin_46217160的博客
09-26 398
Synchronized关键字
关于synchronized
程序员小董的专栏
01-03 2128
如果用synchronized修饰一个类成员方法A,那么就不会出现下面的情况: 同时多个线程访问这个类的A方法。 当然如果还有一个方法B,它没有被synchronized修饰,那么A方法与B方法是可以并行执行的。如下: package thread; public class SyncTest implements Runnable { public synchroniz
InterruptedException与interrupt()方法
qq_42082278的博客
04-19 214
Interrupted异常 什么情况下会抛出Interrupted异常 假设while循环中没有调用任何的阻塞函数，就是通常的算术运算，或者打印一行日志，如下所示 2、 轻量级阻塞与重量级阻塞 能够被中断的阻塞称为轻量级阻塞，对应的线程状态是WAITING或者TIMED_WAITING；而像synchronized 这种不能被中断的阻塞称为重量级阻塞，对应的状态是 BLOCKED。如图所示：调用不同的方法后，一个线程的状态迁移过程。 初始线程处于NEW状态，调用start()开始执行后，进入RUNNING
synchronized关键字深度解析
sirwsl
08-03 322
Syncharnized深度解析，一文了解synchronized关键字。针对Synchronized关键字进行解析（学习笔记），其中包含synchronized简介，对象锁（代码块、方法锁）、类锁（static静态方法和.class）以及性质（可重入不可中断）和加锁原理、可重入原理、可见性原理，以及synchronized的缺陷做了说明，以及多线程访问同步方法的情况，以及常见的问题
Java正确处理InterruptedException的方法(java并发编程第7章)
u012572955的专栏
02-15 3594
要想讨论正确处理InterrupedtException的方法，就要知道InterruptedException是什么。 根据Java Doc的定义 Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or durin
Java 理论与实践: 处理 InterruptedException
朝着梦想 渐行前进
10-10 1655
这样的情景您也许并不陌生：您在编写一个测试程序，程序需要暂停一段时间，于是调用 Thread.sleep()。但是编译器或 IDE 报错说没有处理检查到的 InterruptedException。InterruptedException 是什么呢，为什么必须处理它？ 对于 InterruptedException，一种常见的处理方式是 “生吞（swallow）” 它 —— 捕捉它，然后什么
【Java并发编程之深入理解】Synchronized的使用
热门推荐
青苔小榭
09-08 23万+
1.为什么要使用synchronized 在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。 2.实现原理 synchronized可以保证方法或者代码块在运行时，同...
使用Wait()方法的注意事项：This code may throw an InterruptedException
长不大的大灰狼
08-08 660
1 选择 void waitForSignal() { Object obj = new Object(); synchronized(Thread.currentThread()) { obj.wait(); obj.notify(); } } Which statement is true? 第一个错误是掷出中断异常InterruptedException，要对 wait() 方法以try/catch 包覆或在方法上声明异常信息。void waitForSignal() throws Inte
InterruptedException详解
m0_37041378的博客
10-24 7600
1.线程为什么会抛出InterruptedException？ 假如现在有两个线程1和2；线程1在正常执行，此时线程2调用了线程1的interrupt方法；代码如下： @RunWith(SpringJUnit4ClassRunner.class) public class SynchronizedTest { @Test public void testSynchroniz
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值