Java学习笔记34

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量31 收藏
点赞数
分类专栏： Java SE 学习笔记合集 文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53983068/article/details/132260855
版权

Java笔记34

死锁

  • 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就有可能会发生“死锁”的问题。
  • 下面我们写一个程序来帮助我们理解死锁：
    • 有两个女孩（灰姑娘和白雪公主）准备化妆，化妆品有两件：口红和镜子各一件，每件化妆品都上了锁，只有获得了某化妆品对应的锁的人才能使用该化妆品；
    • 灰姑娘和白雪公主都想化妆（一个完整的化妆过程：先获得一件化妆品的锁 --> 使用该化妆品化妆 --> 再获得另一件化妆品的锁 --> 使用另一件化妆品化妆 --> 化妆完毕！）；
    • 灰姑娘选择了先获得口红的锁，而白雪公主选择了先获得镜子的锁；
    • 当灰姑娘和白雪公主使用完了自己已获得的化妆品后，就想获取对方占有的另一件化妆品继续化妆；
    • 但双方都不愿意放弃自己已经占有的化妆品（方法中的某个同步块拥有“两个以上对象的锁”，导致两个线程都不释放锁），于是双方形成了僵持，谁也拿不到对方占有的化妆品，谁都不能完成一个完整的化妆过程，就形成了死锁。
  • 具体代码如下：
package com.clown.lock;

//死锁：多个线程互相占有着对方需要的资源，形成僵持。
public class DeadLock {

    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0, "灰姑娘");
        Makeup girl2 = new Makeup(1, "白雪公主");

        girl1.start();
        girl2.start();
    }

}


//口红
class Lipstick {

}


//镜子
class Mirror {

}


class Makeup extends Thread {

    //需要的资源只有一份，用 static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;  //选择
    String girlName;  //使用化妆品的人

    //构造器
    public Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁，即各自都需要拿到对方的资源
    public void makeup() throws InterruptedException {
        if (choice == 0) {  //选择的是先获得口红
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得了口红的锁");
                //休眠 1秒
                Thread.sleep(1000);
                System.out.println(this.girlName + "使用口红化了妆");
                synchronized (mirror) {  //使用完口红后，想要获取镜子的锁
                    System.out.println(this.girlName + "获得了镜子的锁");
                    //休眠 1秒
                    Thread.sleep(1000);
                    System.out.println(this.girlName + "使用镜子化了妆");
                    System.out.println(this.girlName + "化妆完毕！");
                }
            }
        } else {  //选择的是先获得镜子
            synchronized (mirror) {
                System.out.println(this.girlName + "获得了镜子的锁");
                //休眠 1秒
                Thread.sleep(1000);
                System.out.println(this.girlName + "使用镜子化了妆");
                synchronized (lipstick) {  //使用完口红后，想要获取口红的锁
                    System.out.println(this.girlName + "获得了口红的锁");
                    //休眠 1秒
                    Thread.sleep(1000);
                    System.out.println(this.girlName + "使用口红化了妆");
                    System.out.println(this.girlName + "化妆完毕！");
                }
            }
        }
    }

}
  • 运行结果：

在这里插入图片描述

  • 可以发现，两个线程都是运行到一半就卡死了。灰姑娘只得到了口红的锁，而得不到镜子的锁，所以只使用口红化了妆就卡住了；而白雪公主则只得到了镜子的锁，而得不到口红的锁，所以只使用镜子化了妆就卡住了。
  • 那么我们该如何修改代码使其不发生死锁呢？解决方法如下：
  • 在上述代码中，我们的同步块是这样的：
synchronized (obj1) {
    //代码块
    synchronized (obj2) {
        //代码块
    }
    //代码块
}
  • 此时包裹在外面的这个同步块同时拥有“两个以上对象的锁”，所以会出现死锁。
  • 我们只需要将我们的同步块修改为下面这样就能避免发生死锁：
synchronized (obj1) {
    //代码块
}
synchronized (obj2) {
    //代码块
}
  • 上述的修改方法总结下来就是：将一个同步块中嵌套的同步块拿出来放在外面，不让其中某一个同步块同时拥有“两个以上对象的锁”，这样就可以避免死锁的发生。
  • 具体到上述程序，修改后的代码为：
package com.clown.lock;

//死锁：多个线程互相占有着对方需要的资源，形成僵持。
public class DeadLock {

    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0, "灰姑娘");
        Makeup girl2 = new Makeup(1, "白雪公主");

        girl1.start();
        girl2.start();
    }

}


//口红
class Lipstick {

}


//镜子
class Mirror {

}


class Makeup extends Thread {

    //需要的资源只有一份，用 static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;  //选择
    String girlName;  //使用化妆品的人

    //构造器
    public Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆，互相持有对方的锁，即各自都需要拿到对方的资源
    public void makeup() throws InterruptedException {
        if (choice == 0) {  //选择的是先获得口红
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得了口红的锁");
                //休眠 1秒
                Thread.sleep(1000);
                System.out.println(this.girlName + "使用口红化了妆");
            }
            synchronized (mirror) {  //使用完口红后，想要获取镜子的锁
                System.out.println(this.girlName + "获得了镜子的锁");
                //休眠 1秒
                Thread.sleep(1000);
                System.out.println(this.girlName + "使用镜子化了妆");
                System.out.println(this.girlName + "化妆完毕！");
            }
        } else {  //选择的是先获得镜子
            synchronized (mirror) {
                System.out.println(this.girlName + "获得了镜子的锁");
                //休眠 1秒
                Thread.sleep(1000);
                System.out.println(this.girlName + "使用镜子化了妆");
            }
            synchronized (lipstick) {  //使用完口红后，想要获取口红的锁
                System.out.println(this.girlName + "获得了口红的锁");
                //休眠 1秒
                Thread.sleep(1000);
                System.out.println(this.girlName + "使用口红化了妆");
                System.out.println(this.girlName + "化妆完毕！");
            }
        }
    }

}
  • 运行结果：

在这里插入图片描述

  • 修改后，灰姑娘和白雪公主都在使用完各自最初占有的化妆品后释放了该化妆品的锁，接着获取了对方之前占有的化妆品，完成了完整的化妆过程，没有出现死锁。

死锁的避免方法

  • 产生死锁的四个必要条件：

      1. 互斥条件：一个资源每次只能被一个进程使用。
      1. 请求与保持条件：一个进程因请求资源而阻塞时, 对已获得的资源保持不放。
      1. 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
      1. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

  • 上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生。

Lock（锁）

  • 从 JDK 5.0 开始，Java提供了更强大的线程同步机制 – 通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock（可重入锁）

  • ReentrantLock类（可重入锁）实现了Lock接口，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
  • 使用ReentrantLock类加锁和释放锁的方法：
class A{
	private final ReentrantLock lock = new ReenTrantLock();
	public void method(){
		lock.lock();  //加锁
		try{
			//保证线程安全的代码;
		}
		finally{
			lock.unlock();  //释放锁
			//如果同步代码有异常，要将 unlock()写入 finally语句块（通常都可以直接添加）
		}
    }
}
  • 下面我们来写一个程序来测试一下Lock锁：
    • 模拟买火车票：只有10张火车票，三个线程：小明、小红和黄牛党都来买这10张票。
    • 首先，我们先不使用ReentrantLock类，不加锁。
  • 具体代码如下：
package com.clown.lock;

//测试 Lock锁
public class TestLock {

    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2, "小明").start();
        new Thread(testLock2, "小红").start();
        new Thread(testLock2, "黄牛党").start();
    }

}


class TestLock2 implements Runnable {

    int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums > 0) {
                //sleep();  放大问题的发生性
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- +"张票");
            } else {
                break;
            }
        }
    }

}
  • 运行结果：

在这里插入图片描述

  • 观察运行结果我们可以发现：结果中不仅出现了同一张票被多个人拿到的情况，还出现了“XXX拿到了第（负数）张票”的情况，这说明没有加锁的情况下，我们的程序在多线程环境下是线程不安全的。
  • 接下来我们再在上面的程序中添加Lock锁：
    • 我们先使用Lock接口的ReentrantLock实现类在上述代码的线程类中创建一个实例对象lock；
    • 接着在方法中添加try/finally语句;
    • 然后在try{}前使用lock对象的lock()方法加锁；
    • 再在try{}中添加我们想要保证线程安全的代码块；
    • 最后在finally{}中使用lock对象的unlock()方法释放锁。
  • 具体代码如下：
package com.clown.lock;

import java.util.concurrent.locks.ReentrantLock;

//测试 Lock锁
public class TestLock {

    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2, "小明").start();
        new Thread(testLock2, "小红").start();
        new Thread(testLock2, "黄牛党").start();
    }

}


class TestLock2 implements Runnable {

    int ticketNums = 10;

    //定义 lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //sleep();  放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            //加锁
            lock.lock();
            try {
                if (ticketNums > 0) {
                    System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- +"张票");
                } else {
                    break;
                }
            } finally {
                //解锁
                lock.unlock();
            }
        }
    }

}
  • 运行结果：

在这里插入图片描述

  • 观察运行结果，使用ReentrantLock加锁后程序的运行结果符合我们的预期，没有发现问题，说明加了Lock锁之后的程序在多线程环境下是线程安全的。

synchronized与Lock的对比

  • Lock是显式锁（手动开启和关闭锁，别忘记关闭锁）；synchronized是隐式锁， 出了作用域自动释放。
  • Lock只有代码块锁；synchronized有代码块锁和方法锁。
  • 使用Lock锁，JVM 将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）。
  • 优先使用顺序：
    • Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）
Bald Monkey
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java学习笔记总结
04-02
自己几个月的学习总结，一些解决问题的办法，很实用，希望对大家有所帮助！
java学习笔记.zip
11-16
java学习笔记java学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记...
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7126
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
JAVA学习笔记：目录
任性的生鱼片 的博客
12-28 1932
目录 java学习笔记1：了解java、JDK、JRE、JVM java学习笔记2：JDK下载和安装以及测试控制台测试是否配置成功 java学习笔记3：用记事本写第一个java程序，第一个java程序常见错误总结，第一个java程序详细解析 java学习笔记4：常见的DOS命令和java开发工具 java学习笔记5：eclipse的下载及使用，以及java程序的运行 java学习笔记6：注释、标识...
Java 学习笔记：面向对象
Li__Daxia的博客
03-19 988
Java 学习笔记：面向对象
Thinking in Java读书笔记
热门推荐
yjclsx的博客
07-31 42万+
Thinking in Java读书笔记（IO和并发除外） 1.1、类中所有的private方法都隐式地指定为final的，由于其他类无法取用private方法，所以也就无法覆盖它；private方法无法被重写，继承对应private的方法无效，private的属性也无法拿到，但我们通常private的属性有对应的get、set方法，通常是public的，所以子类继承后可以调用方法来取得到父类的...
JAVA学习笔记（韩顺平老师）
2301_77385325的博客
04-19 1670
说明：本文为韩顺平老师的JAVA课程学习笔记，仅供自身学习参考，如有纰漏，请多指教，如有帮助，不胜荣幸。
Java学习笔记一
u013033706的博客
10-23 1447
Java学习笔记一1、Java语言的特点2、Java程序开发过程3、Java虚拟机JVM 学习方式： 书籍：《Java基础教程》 吴仁群 清华大学出版社 1、Java语言的特点 一种面向对象且与平台无关的多线程动态语言 2、Java程序开发过程 文件名.java产生applicationapplets源文件编辑器Java编译器字节码文件由Java解释器执行由Web浏览器执行 图1 Java程...
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
java学习笔记
Wudu_Eleven的博客
12-11 2万+
java是一门很好的语言，也是一门庞杂的系统，学习过程中要善于记录和积累。  学习了四年java，但回头看看好像什么都没学到，是因为学习没有成系统，知识没有成系统。 面向对象编程有很多重要的特性， 比如：封装，继承，多态和抽象。下面的章节我们会逐个分析这些特性。 封装 封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数
Java学习笔记目录索引 (持续更新中)
Guizy
01-15 12万+
Java学习路线目录索引 一、Java基础(省略) Lambda表达式及函数式接口 二、Java数据库 MySQL 一 概念、DDL、DML、DQL、事务、约束等 数据库设计 一 多表关系、三大范式 JDBC 一 基本使用、DAO组件、连接池、JDBCTemplate 三、JavaWeb HTML相关学习 CSS — 常用属性 CSS — 选择器及三大特性 CSS — 网页的布局方式 C...........................
Java 学习笔记(手写版)
心海非海_のBlog
10-25 2401
Java 学习笔记(手写版) 文章目录Java 学习笔记(手写版)变量控制流程包机制 & 用户交互 Scanner方法（函数） & 驼峰命名法递归 & 数组OOP & 构造器封装继承 （super & this）方法重写 静态方法 & 非静态方法多态 & instance of & 类型转换static 关键字抽象类接口 & 实现类内部类正则表达式异常注解反射//..多线程基本概念线程创建静态代理模式 & 函数式接口 &amp
Java基础 学习笔记 Markdownr版
06-27
Java基础 java学习笔记 Java Java基础Markdown学习笔记，可转换成PDF、Word等格式
java学习笔记资源合集
05-25
java学习笔记 Java 自 1995 年诞生，至今有 16 年的历史，从诞生之日起，逐渐被广泛接受并成为推 动了 web 迅速发展。Java 的三种核心机制为虚拟机机制、代码安全机制、垃圾回收机制。 Java 最大的特点是平台无关性...
Java学习笔记学习笔记
10-24
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习...
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 995
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 792
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 293
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 257
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java 学习笔记 xmind
01-02
Java 学习笔记 XMind 是一款专门用于整理和管理 Java 学习内容的思维导图软件。通过 XMind，我们可以将 Java 相关的知识点、重点、代码案例、类库等内容进行整理和分类，方便我们进行学习和复习。 首先，我用 XMind...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值