JAVA的多线程、死锁、线程间通信、如何规避死锁、线程安全的单例模式

最新推荐文章于 2024-07-04 10:16:22 发布
最新推荐文章于 2024-07-04 10:16:22 发布
阅读量353 收藏 3
点赞数
文章标签： 多线程 线程间通信 死锁 如何规避死锁 线程安全的单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42036256/article/details/103429201
版权

主要内容：

多线程

线程和进程间的关系

进程：计算机中每一个活跃的程序（软件），都是一个独立的进程，进程之间可以是并列的关系，也可以是相互通信的关系
线程：在同一个进程中，负责不同功能的子操作，称之为线程

  • 计算机：国家
  • 软件进程：各省市+省部级机构
  • 线程：省下属市级单位+厅局级单位

在这里插入图片描述
计算机中软件并行的原理：（单CPU情况）
现在的计算机都是电子计算机，电子计算机单个CPU对进程的处理都是“伪多进程”。
计算机的主板上有一个“时钟芯片”组件，时钟芯片负责按照一定的规律发送脉冲，每一个脉冲，我们称之为一个“时间片”。
时间片就是软件执行的“令牌”，哪个软件能够抢到当前的时间片，就能够占用所需的计算机资源。反之，如果其他进程没有抢到时间片，程序将被暂时性“挂起”，直到程序（进程）抢到时间片为止
计算机中的时间片单位是“纳秒”，时间片足够小，计算机的反应足够快，所以在进程抢时间片，导致程序切换的过程中。
人类是无法察觉得，所以我们“觉得”计算机中的软件（进程）是并行的。
在这里插入图片描述

Java中的线程理论

Java程序中的线程机制：
猜测一个Java程序运行时，有多少个线程一起工作：

  1. JVM运行时，需要一个线程
  2. 垃圾回收机制，需要一个线程
  3. 代码本身还需要一个线程

注意：一个Java程序如果要运行（刨除JVM和垃圾回收机制这些辅助线程），至少需要一个线程，这个线程就是代码本身
一个程序在main方法中执行的时候，至少有一个线程代表当前程序本身，就是main线程，也就是主线程

Java中线程的实现方式：

  1. 继承Thread类
  2. 实现Runnable接口
  3. 继承TimerTask类
  4. 实现Callable接口

线程的生命周期问题：

  1. 怀孕阶段：创建了一个线程对象，但是这个线程尚未运行
  2. 出生阶段：执行线程中的启动方法，这个线程进入准备阶段
  3. 参加工作：线程得到系统时间片，有资格占用系统和硬件资源，可以执行线程的任务
  4. 下班休息：线程处于休眠状态，线程占用的资源不会被交出
  5. 辞职离岗：此时这个线程处于挂起状态，不参与时间片的抢夺，交出所有占用的系统资源
  6. 重新上岗：此时这个线程被唤醒，重新加入到时间片的争夺当中
  7. 退休回家：此时这个线程进入到了结束状态下
  8. 入土为安：线程的对象呗垃圾回收器回收，这个线程彻底进入消亡状态

在这里插入图片描述
在这里插入图片描述
线程的生命周期状态：

  1. 创建线程对象：
    线程尚未启动，没有加入线程池当中，不归线程池调度管理
  2. 准备状态：
    此时的线程已经启动，加入线程池当中，接受线程池的调度管理，但是此时线程尚未得到时间片资源
  3. 运行状态：
    在准备状态的基础上，线程得到时间片资源，真正执行线程中的代码
  4. 休眠状态：
    线程不放弃现有资源（不是时间片），但是也不执行线程中的代码，这个线程不参与时间片的抢夺，休眠状态的线程，在休眠时间到的情况下，会自动唤醒
  5. 挂起状态：
    挂起状态下，线程依然不抢夺时间片，但是会释放占用资源，挂起状态下的线程，需要等待其他线程的唤醒
  6. 阻塞状态：
    线程正在执行过程当中，等待一些其他资源，例如：IO流的读写、键盘的输入
  7. 结束状态：
    线程结束运行，释放所有资源，退出线程池的管理

Java中线程类的实现方式

  1. 继承Thread类：
/**
 * 自定义线程类
 * 自定义线程类型的目的，就是为了重写Thread类中的run()方法
 * run()方法中的代码就是这个线程执行的任务
 */
public class MyThread extends Thread {

    @Override
    public void run() {

        //重写run()方法，让自定义线程具有我们约定的执行内容
        System.out.println("Brother La is Beautiful!");
    }
}

MyThread mt1 = new MyThread();  //创建线程对象，此时线程对象处于新建状态，没有加入线程池的管理

        /*
         * 注意：
         * 如果直接调用一个线程对象的run()方法
         * 那么相当于直接调用一个普通的对象方法，
         * 线程依然无法加入线程池当中
         * 执行这个run()方法的不是线程本身，而是main线程
         */
        mt1.run();

        /*
         * 只有通过start()方法启动一个线程，
         * 才能够将这个线程加入线程池的管理当中
         * 所以，调用start()方法，才是启动一个线程的正确方式
         */
        mt1.start();
  1. 实现Runnable接口：
public class MyRunnable implements Runnable {
    @Override
    public void run() {

        //重写run()方法，让自定义线程具有我们约定的执行内容
        System.out.println("Brother La is Beautiful!");

    }
}

 MyRunnable mr1 = new MyRunnable();  //通过Runnable接口实现类创建一个线程任务对象
 Thread t1 = new Thread(mr1);  //创建一个Thread对象，作为线程任务的执行者
 t1.start();  //通过任务的执行者，来执行线程任务

继承Thread类和实现Runnable接口的区别和关系：
区别：

  1. Thread类型中，不仅仅具有run()方法（Thread也实现了Runnable接口），而且在Thread类型当中体现了线程的特性，并且提供了操作线程的各种方法；但是在Runnable接口中，只有一个run()方法，并没有体现线程的特性，也不能操作线程
  2. Thread类本身描述的是线程任务的执行者，Runnable接口的实现类描述的是线程的任务一个任务同时可以由多个执行者执行；但是一个执行者同时只能够执行一个任务；任务和执行者是一对多的关系。
    我们将一个任务由多个执行者执行的状态，称之为“多线程编程”

关系：

  1. 创建一个Runnable接口实现类的对象，就相当于定义了一个线程任务，而Thread类对象，是线程任务的执行者
  2. 至于一个执行者执行什么任务，取决于在创建这个执行者的时候，传递什么样的任务对象

Java中线程的常用方法

Thread中的常用方法：
实际上就是Thread类中提供的常用方法：

public class TestThread {

    public static void main(String[] args) {

        MyRunnable mr = new MyRunnable();
        //可以在线程的构造器中为线程命名
        Thread t1 = new Thread(mr, "执行线程t1");  
//      t1.run();

//      System.out.println(t1);

        //[1]通过start()方法讲一个线程开始执行，加入线程池的管理序列
//      t1.start();

        //[3]给线程进行命名
//      t1.setName("执行线程t1");
        
        //[6]给线程指定优先级，优先级的取值范围是1~10之间，越界则抛出IllegalArgumentException异常
        /*
         * 线程的优先级描述的不是一个线程启动的先后顺序
         * 线程的优先级描述的是这个线程对资源的占用比率
         * 线程的优先级越高，线程对资源的占用比率就越大
         * 线程的优先级越高，抢到时间片的概率就越大，执行的次数就越多
         */
        t1.setPriority(Thread.MAX_PRIORITY);

        /*
        Thread t2 = new Thread(mr);
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        */
        t1.start();
    }
}

public class MyRunnable implements Runnable {
    public MyRunnable() {
        /*
         * 注意：
         * 在线程或者Runnable的构造器中
         * 执行这个构造器的不是当前线程
         * 是调用这个构造器创建对象的程序的所在线程
         */
        System.out.println(Thread.currentThread());
    }

    @Override
    public void run() {
        while(true) {
            //[2]返回一个Thread对象，这个Thread对象代表当前正在执行这段代码的线程对象
            /*
             * 注意：
             * 如果run方法被以对象方法的形式调用
             * 在run方法中的Thread.currentThread()返回的也不是当前线程
             * 返回的是调用这个run方法的线程
             * 因为此时，当前线程并没有加入线程池当中
             * 直接调用run方法相当于调用了一个普通的对象方法
             */
             //[4]获取线程的名字
             //System.out.println(Thread.currentThread().getName());  

            /*
             * 一个线程的ID是由线程池来分配的
             * 这个ID不能手动赋值
             */
             //[5]获取线程的ID编号
//          System.out.println(Thread.currentThread().getId());  
            
            //[7]获取一个线程的优先级
            System.out.println(Thread.currentThread().getPriority());  

            /*
             * 如果一个线程处于运行状态、准备状态、休眠状态、挂起状态、阻塞状态下
             * isAlive()方法，返回的都是true;
             * 如果一个线程处于创建状态和结束状态下
             * isAlive()方法，返回的都是false
             */
             
             //[8]判断一个线程是否处于存活状态
            System.out.println(Thread.currentThread().isAlive());  
            System.out.println("博主最帅!");
            
            //[9]线程的休眠方法
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

如何停止一个线程：

public class TestThread {
    public static void main(String[] args) {

        MyRunnable rm = new MyRunnable();
        Thread t1 = new Thread(rm, "我是一个执行线程");
        t1.start();

        try {
            Thread.sleep(3 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        /*
         * 如果一个线程当前正处于休眠状态下
         * 此时给这个线程设置断点
         * 将会引发sleep方法抛出InterruptedException
         */
        t1.interrupt();  //通过这个方法，给一个线程设置中断标记位true，代表这个线程已经被中断了
    }
}

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        Thread currentThread = Thread.currentThread();
        /*
         * 利用currentThread.isInterrupted()方法和try-catch异常处理来结束线程
         * 1.将线程中循环的条件置为!currentThread.isInterrupted()
         * 只要没有通过其他线程对当前线程进行中断，线程中的循环就会继续
         * 2.如果线程中存在sleep方法，那么一个线程如果处于sleep状态下，对这个线程进行中断
         * sleep方法将会抛出InterruptedException
         * 此时通过在循环外侧添加try代码段，尝试执行这个循环，
         * 一旦循环内部抛出异常，通过catch代码段进行捕获
         * 如果进入catch代码段中，相当于循环已经退出
         * 如果run方法后序没有其他内容，这个线程的任务就完成了，线程自动结束
         */
        try {
            while(!currentThread.isInterrupted()) {
            
                //在线程内部，我们可以通过thread.isInterrupted()返回一个boolean值，表示这个线程是否被中断
                System.out.println(currentThread.getName() + ", " + currentThread.isInterrupted());

                /*
                 * sleep方法并不是百分之百安全的
                 * 如果一个线程处于sleep状态下，此时为这个线程进行中断
                 * sleep方法将会抛出InterruptedException
                 * 这个异常并不可怕，最要命的是这个异常将会清除当前线程的中断状态(Interrupted Status)
                 * 如果当前线程的中断状态被清除到false状态，这个线程中的方法，将会继续执行
                 */
                Thread.sleep(500);
            }
        }catch (InterruptedException e) {
            System.out.println("当前线程已经结束了");
        }
    }
}

守护线程的作用：

public class TestThread {
    /*
     * 父级线程和子线程的关系：
     * 如果一个线程之下，还会启动其他的线程
     * 被这个线程启动的，称之为这个线程的子线程
     * 当前线程称之为子线程的父级线程
     * 父级线程的启动顺序一定在子线程之前
     * 
     * 同级别的子线程启动顺序是随机的
     * 首先调用start()方法的线程不一定优先取得时间片
     */
    public static void main(String[] args) {

        /*
         * 在当前程序中
         * 如果存在守护线程
         * 守护线程会在其他所有线程执行完毕之后，自动退出
         * 不需要手动进行守护线程的中断操作
         * 但是如果当前程序中还有其他线程在运行，守护线程就会一直运行下去
         * 
         * JVM中，执行垃圾回收的线程，就是典型的守护线程
         * 
         * 总结：
         * 守护线程守护的是同一个线程池当中的其他线程
         * 如果在同一个线程池当中具有其他线程尚未结束
         * 此时，守护线程也不会结束
         * 注意：守护线程守护的其他线程，不区分父级和子级
         */
        DeamonThread dt = new DeamonThread();
        dt.setDaemon(true);  //设定这个线程为守护线程

        UserThread ut = new UserThread();
        //设定这个线程为用户线程，默认情况下一个线程就是用户线程
        ut.setDaemon(false);  
        ut.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dt.start();
        while(true) {
            System.out.println("我是父级线程");
        }
    }
}

线程安全性问题

线程安全性问题的本质：
多线程执行任务的本质是计算机的时间片占有在多个线程之间进行切换，当一个线程的步骤没有完全结束之前，其他线程有可能抢夺时间片，其他线程在获得时间片之后会占用共享资源，这就有可能导致数据的脏读写

***脏读写：***我们当前线程获得的数据是其他线程经过修改但是我们不知道的数据，脏读写可能会导致脏数据的出现

***总结：***在多线程的环境下，资源的共享有可能导致脏读写，脏读写可能导致脏数据。
为了在多线程环境下避免脏读写导致脏数据，就要给共享资源对象加上同步锁（synchronized），同步锁锁定的是共享资源对象，共享资源对象被锁定的是这个对象的使用权。
所以说，在同步锁代码块中的步骤都是对共享资源的修改步骤，这些步骤在多线程之间是同步执行的，因为这些步骤在执行的过程当中受synchronized的影响，不会释放对共享资源的占有。
在synchronized代码段当中，对资源的读写是独享（同步）的不是共享（异步）的，如果被读写的资源成为独享资源，对这个资源的操作过程就是线程安全的，就不会出现数据的脏读写，也就不会导致脏数据，如果一个过程时线程安全的，我们称这个过程是“原子化”的操作过程

不要滥用synchronized：
synchronized代码段本身是执行同步方法（代码）的作用的
如果synchronized代码段的要影响范畴过大，会造成不必要的资源浪费
例如：在火车票售票的案例中：
通过线程休眠模拟的找零钱过程，不涉及到同步执行，就不应该存在于synchronized代码段当中

 @Override
    public void run() {
        try {

            while(!Thread.currentThread().isInterrupted()) {
                synchronized(tp) {
                    sale();
                }

                /*
                 * 这种找零钱的过程
                 * 多个窗口之间互不影响
                 * 也没有涉及到对共享资源tp的读写
                 * 所以不需要保证同步，异步执行即可
                 * 这种费时的操作如果在多个线程之间一步执行，可以提升多线程的总体效率
                 */
                Thread.sleep(1000);  //模拟找零钱的过程
            }
        }catch(InterruptedException e) {

            System.out.println("车票已售完！");

        }
    }

在sleep状态下，线程对锁对象的控制：
如果一个线程处于sleep（休眠）状态下，当前线程并不会释放他所占用的锁对象。
也就是说，一个线程中如果存在休眠操作，那么这个操作一般不应该放在synchronized代码段当中。
一个线程如果处于sleep状态下，这个线程是不会参与抢夺时间片的。
在这里插入图片描述
在同步代码段中的锁对象是不能发生变化的：
多线程同步代码段锁定的所对象，应该在多个线程之间共享，具有共同的约束力。
如果一个锁对象在多个线程之间会发生变化，就不会具有多线程之间的共同约束力。
不具有共同约束力的锁对象，依然会引起线程的不安全，所以，类似String和包装类对象的，存在自动建包的对象，一般不能作为锁对象使用。

线程间通信

概念：一个线程启动之后，可以对其他线程进行通知，通知其他线程启动或等待
典型应用：生产者消费者模型
手段：wait()/notify()/notifyAll()

睡美人的故事：
从前，有一个公主（一个线程），因为这个公主太漂亮了，被一个巫师（男的）看上了
公主不喜欢巫师，于是，在一个夜黑风高的晚上，巫师潜入城堡，锁上门……
给公主下了一个咒语，公主睡着了（线程进入挂起状态）
N多年之后……
巫师摇身一变，成为XX国王子，再次回到这个城堡中
进入了那一道他熟悉的门中，锁上门……
这个王子（巫师本人），终于得偿所愿，亲了公主一口
结果因为嘴太臭，公主被熏醒了（线程被唤醒）
从此公主和王子（巫师）过上了羞羞的生活……（全剧终）

从故事中得到的技术启发：

  1. 如果一个线程在运行过程中，有一个对象在这个线程中调用wait()方法，这个线程将进入等待（挂起）状态；如果其他线程中，有对象调用notify()/notifyAll()方法，挂起的线程有可能被唤醒
  2. 只有在synchronized代码段中，才能够调用wait()方法或者notify()/notifyAll()方法，否则将会抛出异常：IllegalMonitorStateException
  3. 等待之前加锁的对象、执行wait()方法的对象、唤醒之前加锁的对象、执行notify()/notifyAll()方法的对象，必须是同一个对象
  4. sleep方法和wait方法，都会让线程暂停（这个线程不去争抢时间片），但是在sleep引起的休眠状态下，当前休眠的线程不会释放线程锁对象，其他线程依然无法取得这个锁对象；在wait引起的挂起状态下，挂起线程会释放线程的锁对象，其他线程可以对这个锁对象进行争取
  5. 通过wait方法进入挂起状态的线程，一旦被唤醒，将从wait()方法之后继续执行这个线程的run方法
  6. notify()方法是随机唤醒线程池当中的一个挂起线程，至于唤醒谁，不一定；notifyAll()方法会对线程池当中所有的线程发送唤醒信号，挂起的线程会被唤醒，没有挂起的线程将忽略这个信号

案例1：
一个生产者，一个消费者，仓库容量为1

案例2：
三个生产者，三个消费者，仓库容量为1
在这里插入图片描述
遇见问题：
问题1：过度生产和过度消费

问题原因：

  • notify()方法的作用是随机唤醒线程池中的一个挂起线程，如果上一个执行线程的是生产者1号，生产者1号唤醒的是生产者2号，那么从wait()方法的特点来说，我们会从生产者2号的wait()方法继续向下执行，不会回头重新执行if判断，最终导致过度生产，过度消费的原理也是相同的

在这里插入图片描述
解决方案：

  • 将生产方法和消费方法中的if判断语句，改为while循环语句
    在wait()方法结束，线程被唤醒的时候，重新执行while循环的条件判断
    将一次性的if使用可重复的while取代

问题2：6个线程都卡死了（死锁问题）

问题原因：

  • 死锁的原理：一个线程的代另一个线程持有的锁对象，但是另外一个线程始终不释放这个所对象

本例中死锁的原因：

  • 消费者唤醒消费者，生产者唤醒生产者，最终导致所有的生产者和消费者都进入等待状态，此时的线程锁被空置，此时没有其他线程能够唤醒等待的线程

在这里插入图片描述
解决方案：

  • 使用notifyAll()方法替换生产过程和消费过程当中的notify()方法
    每一次都对所有的线程发出唤醒信号，等待的线程都被唤醒，没有等待的线程忽略这个信号

线程的死锁

死锁的概念：
在多个线程之间，具有多个共享资源，其中一个线程如果想要运行，需要占用1个以上的公共资源。
如果一个线程在占据1（n）个公共资源的前提下，去争夺剩余的公共资源，如果争取不到，原有的公共资源不进行释放。
那么就有可能导致其他的线程也得不到所需的所有公共资源，导致所有的线程都进入挂起状态等待资源，这种状态就是多线程的死锁状态。

死锁状态的典型案例是：哲学家就餐问题
在这里插入图片描述
哲学家就餐问题的描述：
一张桌子周围有5位哲学家，每位哲学家每天的状态只有两种：吃饭状态和思考状态，每位哲学家在吃饭的时候，需要获取左右手两边的叉子才能够就餐如果所有的哲学家，我们统一约定：

  1. 编号为n的哲学家能够获取的叉子编号为：n和(n+1)%5
  2. 同一位哲学家只有同时获取左右两支叉子才能够就餐，否则等待叉子资源
  3. 每一位哲学家就餐的时间是1000毫秒，在这1000毫秒之中，占用两把叉子
  4. 各位哲学家要获取叉子的话，首先获取n号叉子，其次获取(n+1)%5号叉子
  5. 如果一位哲学家获取了一把叉子，这位哲学家将会在保持这把叉子占有的情况下，争取另一把叉子

哲学家就餐问题导致死锁的原因：
如果5位哲学家同时需要就餐，那么5位哲学家将会同时拿起和自己具有相同编号的叉子，将会导致n-1号哲学家永远无法得到另外一把叉子，将会永远处于永远等待资源的状态，此时，死锁产生了。

在哲学家就餐问题中定义的类型：
1.定义叉子类型：
在这个类型当中，我们定义一个长为5的boolean数组forks，数组的每一位都代表下标位n的叉子的占用情况，如果下标位n的叉子取值为true，代表这个叉子正在被占用；如果取值为false，代表当前叉子空闲，在这个类型中，还要定义获取叉子和释放叉子的方法
获取叉子的方法：

  1. 传递一个哲学家对象进来，从这个哲学家的对象中获取哲学家编号
  2. 根据哲学家的编号，计算这个哲学家需要获取哪两把叉子
  3. 定义两个额外的boolean值，表示当前哲学家是否成功获取两把叉子
  4. 获取左叉子，如果获取成功，将forks数组中的n改变为true；如果获取失败，当前哲学家进入挂起状态
  5. 在获取左叉子的基础上，获取右叉子，如果获取成功，将forks数组中的(n+1)%5改变为true；如果获取失败，当前哲学家进入挂起状态
  6. 如果哪一吧叉子没有成功获取，当前哲学家再被唤醒的时候，重新尝试获取这个叉子
  7. 如果两把叉子都能够拿到手，这个哲学家就能够正常就餐

释放叉子的方法：

  1. 传递一个哲学家对象进来，获取哲学家的编号
  2. 计算释放叉子的位置
  3. 放下左叉子，forks[n] = false;
  4. 放下右叉子，forls[(n+1)%5] = false
  5. 唤醒其他哲学家线程，进入唤醒状态

注意：在获取叉子和放下叉子的过程中，都属于对共享资源的读写，需要加锁保证线程安全

2.定义哲学家类型：
为了方便起见，哲学家类型可以直接定义为Thread类型的子类，在哲学家类型中定义思考和吃饭的方法

思考的方法：

  1. 输出当前哲学家名字，进入思考状态
  2. 当前哲学家线程休眠500毫秒
  3. 输出当前哲学家名字，结束思考状态

吃饭的方法：

  1. 输出当前哲学家名字，进入吃饭状态
  2. 当前哲学家线程休眠500毫秒
  3. 输出当前哲学家名字，结束吃饭状态

run方法中，定义的内容：

  1. 定义一个死循环，表示当前哲学家在就餐和思考状态之间不断切换
  2. 循环中，首先进入思考状态
  3. 循环中，获取叉子
  4. 循环中，进入就餐状态
  5. 循环中，放下叉子

注意：在多线程编程的环境下，应该尽量避免死锁问题的出现

如何规避死锁

1.线程自律性方案：
当一个线程在申请多个资源的时候，首先判定是否能够一次性获取所有的资源，如果能够一次性获取所有的资源，再去占用这些资源，反之，如果不能一次性占用所有资源（包含仅占用一部分资源的情况），当前线程将不占用任何资源，剩余的资源将分配给其他线程进行使用，保证其他线程有机会正常运行
在当前案例中体现自律性的代码方案：

  1. 在哲学家申请叉子的情况下，不是直接分配能够到手的叉子
  2. 而是首先通过对叉子占用状态的判断
  3. 决定是否一次性分配两把叉子
  4. 如果两把叉子中有一把（以上）的叉子不能分配给当前哲学家
  5. 两把叉子就都不分配给当前哲学家，哲学家直接进入挂起状态
  6. 此时的哲学家线程将不占用任何相关资源

2.线程他律性方案：
创建一个资源管理器对象，通过资源管理器统一管理所有的公共资源
公共资源管理器具有分配资源的方法，线程在需要资源的时候，不是直接访问资源，而是想资源管理器发出请求。
资源管理器根据线程申请资源的状态，对申请线程进行响应（给申请线程一个返回值），如果资源管理器同意线程对资源占用的申请，线程将能够得到需要的资源进行运行。
反之，如果资源管理器不同意线程对资源占用的申请，那么当前线程将进入挂起状态，如果线程运行结束，释放资源，释放资源的操作也是线程申请资源管理器去执行。

代码实现方案：

  1. 在案例中定义一个“管家”类型，将分配叉子和回收叉子的方法从Fork类当中分离出来
  2. 此时的Fork类型仅是当做资源使用
  3. 如果一个哲学家想要进入就餐状态，首先调用管家对象的叉子分配方法
  4. 如果管家同意哲学家就餐，分配方法就返回true，哲学家获得叉子（在管家的分配方法中执行），哲学家正常就餐
  5. 如果管家不同意哲学家就餐，说明当前资源不足，当前哲学家不能获得任何资源（有一部分也不给）
  6. 如果此时管家不同意，那么当前哲学家线程进入挂起状态
  7. 挂起的哲学家线程，等待其他哲学家线程就餐完毕的notifyAll()唤醒信号
  8. 一旦被唤醒，再次请求管家，判断管家是否能够为自己分配叉子资源
  9. 此时，哲学家就餐完毕后，放下叉子的动作也要通过调用管家对象的方法来执行

注意：管家对象最大的功能就是分配和回收资源，此时多个哲学家线程能够直接访问的公共对象不再是Fork类型对象，因为Fork对象归管家管理，此时多个哲学家线程共享的公共对象应该变为管家对象
在这里插入图片描述

线程安全的单例模式

回忆一下懒汉模式下的单例：

/**
 * 通过懒汉模式实现的单例
 */
public class Singleton {
    //[2]声明单例变量，作为类属性使用
    private static Singleton singleton = null;

    //[1]私有化构造器，防止外界通过构造器创建对象
    private Singleton() {
    }
    //[3]创建一个类方法，只能够通过类名调用，这个方法返回唯一的单例对象
    public static Singleton getObject() {
        //现用现加载
        if(singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

在多线程情况下，懒汉单例模式遇见的问题：
在多个线程中如果同时获取单例对象，并打印其HashCode编码，有可能出现非单例情况
在这里插入图片描述
解决方案：DCL（Double Check Lock：双检查锁）

  1. 第一道锁：
    给获取单例对象的方法加上锁，加的锁是“静态锁”，静态锁的synchronized关键字传递的对象是类名.class，类名.class实际上返回的是Class类型的对象，如果给一个方法或者一个代码段加上静态锁，将会导致这段代码的任何一种访问方式，都是同步执行的，因为静态锁锁定的是当前类的使用权，所以对这个类的任何一种访问方式都是同步的
  2. 第二道锁：
    volatile关键字：
    JVM虚拟机的两种状态：
    • server：服务端状态
    • client：客户端状态

在这里插入图片描述
volatile关键字的作用：这是一个轻量级的锁
凡是带有volatile关键字的属性，在多线程对其读写的时候，强制及时更新
也就是说，凡是带有volatile关键字的属性都不会被拷贝到线程的私有空间当中。
所有线程对这个属性的读写操作都是基于这个属性值本身的读写操作，而不是针对线程私有空间中属性的读写操作，换句话说，volatile关键字会强制将client状态下的属性转换位server状态下的属性

在单例模式中，我们可以将volatile关键字加给单例对象那个类属性，保证在多个线程之间，访问到的单例对象属性是同一个，让多个线程能够及时发现这个单例对象是否已经被创建。

Three_yang
关注
Java多线程---死锁
qbyqby7628的博客
12-10 325
一、死锁的定义 多线程以及多进程改善了系统资源的利用率并提高了系统 的处理能力。然而，并发执行也带来了新的问题——死锁。所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。 二、死锁产生的原因 1.系统资源的竞争 通常系统中拥有的不可剥夺资源，其数量不足以满足多个进程运行的需要，使得进程在运行过程中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可剥夺资源的竞争才可能产生死锁，对可剥夺资源的竞争是不会引起死锁的。 2.进程推进顺序非法 Jav
day21-多线程下的单例模式；死锁；线程通信；线程池
UNknowmer的博客
04-19 220
文章目录单例模式死锁线程通信生产者和消费者线程池 单例模式 单例模式让某个对象只能实例化对象一次，保证只有一个对象，传统的单例模式写法在多线程中是不想的。 if(s==null){ s = new SingLeton(); } 可能会有多个线程进入判断，导致线程创建多个对象。 如果直接在方法加锁可以避免这个效果，可是这样效率实在太低，为了解决这个问题，我们可以利用两次判断来实现只创建一个对象。 if(s==null){ synchronized(SingLeton.class){ if(s==n
Java多线程7：死锁
weixin_34107739的博客
10-03 259
前言 死锁单独写一篇文章是因为这是一个很严重的、必须要引起重视的问题。这不是夸大死锁的风险，尽管锁被持有的时间通常很短，但是作为商业产品的应用程序每天可能要执行数十亿次获取锁->释放锁的操作，只要在这数十亿次操作中只要有一次发生了错误，就可能导致程序中发生死锁，并且即使通过压力测试也不可能找出所有潜在的死锁。   死锁 一个经典的多线程问题。 当一个线程永远地持有一个锁，并且其他线...
Java多线程编程中的死锁问题及解决方法
最新发布
技术萌新缓缓升级ing
07-04 650
死锁是指两个或两个以上的线程在执行过程中互相等待对方释放锁，而导致的永久等待状态。1. 互斥条件：一个资源每次只能被一个线程占用。2. 持有和等待：一个线程已持有至少一个资源，同时等待其他线程释放资源。3. 不可剥夺：线程获得的资源在未使用完之前，不能强行剥夺。4. 环路等待：多个线程形成环路，每个线程等待下一个线程释放资源。在Java多线程编程中，死锁是一个常见的问题。通过了解死锁的原理，使用正确的编程实践和工具，可以有效地预防和解决死锁问题。
Java多线程:线程死锁
清风小阁
03-11 5288
发生死锁的原因一般是两个对象的锁相互等待造成的。 下面用一个实例来构造这种情况： package basic.e_deadlock; import org.apache.log4j.Logger; public class TestDeadLock { public static void main(String[] args) { DeadlockRisk dead = new D
Java多线程之死锁
水木年华的博客
05-20 184
一、死锁介绍 在Java中，一个对象可以有synchronized方法或别的加锁机制来保证线程安全，线程是可以阻塞的，假如第一个线程在等待另一个线程，而后者又在等待别的线程，这样一直下去，直到这个链条上的线程又在等待第一个线程释放锁。这就造成了线程之间相互等待的连续循环，没有哪个线程能够继续，这被称之为死锁。 二、死锁产生的必要条件 互斥条件:指进程对所分配到的资源进行排它性使用，...
Java多线程死锁
weixin_43808717的博客
10-25 147
1. 死锁的概念 死锁：多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有两个以上对象的锁时就可能会发生死锁的问题。简单点说就是多个线程相互抱着对方需要的资源形成僵持状态 例如有小明，小王两个小孩去拿玩具枪和玩具车两个玩具，小明先拿到了玩具车，小王拿到了玩具枪，并且双方都想获得对方的玩具，而且都不愿意先放弃自己手中当前的玩具(没有信任)，这样就会形成一个僵持，都想获得对方的资源。 class Car
java模拟死锁_java多线程学习之死锁的模拟和避免(实例讲解)
weixin_42525569的博客
02-13 281
1.死锁死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。Java 死锁产生的四个必要条件：1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。...
Java编程之多线程死锁与线程间通信简单实现代码
08-29
Java编程之多线程死锁与线程间通信简单实现代码 多线程编程是Java编程中的一种重要技术，它允许程序同时执行多个任务，以提高程序的效率和响应速度。但是，多线程编程也存在一些隐患，其中最常见的就是死锁和线程间...
Java多线程死锁示例
08-27
在本示例中，我们将深入探讨Java多线程死锁的概念，并通过一个具体的代码示例来理解其工作原理和避免策略。 首先，我们来看标题中的关键点——“Java多线程死锁示例”。死锁是多线程编程中的一种异常状态，通常发生...
java 多线程死锁详解及简单实例
08-31
Java多线程死锁是并发编程中一个严重的问题，它发生在两个或更多个线程相互等待对方持有的资源而无法继续执行的情况。理解死锁的概念及其产生原因对于避免和解决这类问题至关重要。 首先，死锁产生的主要原因包括：...
Java Swing多线程死锁问题解析
08-10
Java Swing多线程死锁问题解析 Java Swing多线程死锁问题解析是Java开发者经常遇到的问题之一。在基于Java Swing进行图形界面开发时，经常会遇到多线程问题。如果在图形界面的同一个线程中进行查询和运算工作，则会...
Java多线程之死锁的出现和解决方法
08-29
Java多线程之死锁的出现和解决方法 死锁是指多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不能正常运行。死锁的出现是由于不适当地运用“synchronized”...
Java多线程：死锁
qq_38470315的博客
04-02 845
死锁单独写一篇文章是因为这是一个很严重的、必须要引起重视的问题。这不是夸大死锁的风险，尽管锁被持有的时间通常很短，但是作为商业产品的应用程序每天可能要执行数十亿次获取锁->释放锁的操作，只要在这数十亿次操作中只要有一次发生了错误，就可能导致程序中发生死锁，并且即使通过压力测试也不可能找出所有潜在的死锁。
JAVA多线程之线程死锁
浮煌的博客
09-06 298
什么是死锁？ 所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。 代码演示： public class DeadThreadDemo implements Runnable { private int flag; private static Object object1 = new Object(); private static Object object2 = new Object(); public De
java多线程与死锁_java多线程死锁 Java线程同步与死锁(死锁)
weixin_31921223的博客
02-12 182
Java 线程同步与死锁 学习笔记Java 线程同步与死锁 学习笔记1 多线程共享数据2 线程同步3 同步准则4 线程死锁1、 多线程共享数据在多线程操作中，多个线程可能同时处理同一个资源...haha_zhan2016年09月25日 10:0210431.线程同步多线程引发的安全问题一个非常经典的案例，银行取钱的问题。假如你有一张银行卡，里面有5000块钱，然后你去银行取款2000块钱。正在你取...
【深入】java 单例模式
心有多大，舞台就有多宽
04-06 380
关于单例模式的文章，其实网上早就已经泛滥了。但一个小小的单例，里面却是有着许多的变化。网上的文章大多也是提到了其中的一个或几个点，很少有比较全面且脉络清晰的文章，于是，我便萌生了写这篇文章的念头。企图把这个单例说透，说深入。但愿我不会做的太差。　　首先来看一个典型的实现：复制代码 1 /** 2 * 基础的单例模式，Lazy模式，非线程安全 3 * 优点：lazy，初次使用时实例化单
多线程死锁问题
weixin_30622181的博客
04-11 103
前天俺们谈到了加锁(线程同步)，但是在使用加锁的同时又会带来一个问题，就是死锁。什么叫死锁？所谓死锁: 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。 发生死锁的原因一般是两个对象的锁相互等待造成的。 那么为什么会产生死锁呢？1.因为系统资源不足。2.进程运行推进的顺序不合适。 3.资源分配不当。 ...
Java多线程死锁与通信示例解析及代码
总结来说，学习Java编程时理解多线程死锁的原因、避免死锁的方法以及如何利用线程间通信是至关重要的。通过实际代码演示，开发者可以更好地掌握这些概念，并在实践中避免潜在的性能问题和程序异常。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值