深入浅出Java并发多线程（8）- 线程8大核心基础

最新推荐文章于 2021-12-12 00:37:28 发布
最新推荐文章于 2021-12-12 00:37:28 发布
阅读量211 收藏
点赞数
分类专栏： # Java线程学习笔记 文章标签： 多线程 wait notify notifyAll
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012292754/article/details/111016098
版权

在这里插入图片描述

1 Thread 和 Object 类中的重要方法

在这里插入图片描述

1.1 wait,notify,notifyAll作用、用法

在这里插入图片描述

  • 作用、用法：阻塞阶段 、唤醒阶段、遇到中断
  • 阻塞阶段
    执行 wait方法的时候，必须先具有这个对象的monitor锁

直到遇到以下的4种情况，才会被唤醒：

在这里插入图片描述

1.1.1 普通用法

/**
 * @Description wait和notify的基本用法
 * 1、代码执行顺序
 * 2、证明 wait释放锁
 * @Author tzb
 * @Date 2021/2/8 18:08
 * @Version 1.0
 **/
public class Wait {

    public static Object obj = new Object();

    static class Thread1 extends Thread {
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
                // 释放锁
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程"+ Thread.currentThread().getName() + "获得锁");
            }
        }
    }

    static class Thread2 extends Thread{
        @Override
        public void run() {
            synchronized (obj){
                obj.notify();
                System.out.println("线程" + Thread.currentThread().getName() + "调用notify");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();

        thread1.start();
        Thread.sleep(200);

        thread2.start();

    }

}

在这里插入图片描述

1.1.2 notify和notifyAll的用法

/**
 * @Description 3个线程，线程1和线程2首先被阻塞，线程3唤醒他们。、
 * 1、start先执行，不代表线程先启动
 * @Author tzb
 * @Date 2021/2/8 18:28
 * @Version 1.0
 **/
public class WaitNotifyAll implements Runnable {

    private static final Object resourceA = new Object();

    @Override
    public void run() {
        synchronized (resourceA) {
            System.out.println(Thread.currentThread().getName() + " 获取resourceA lock");

            try {
                System.out.println(Thread.currentThread().getName() + " 等待开始");
                resourceA.wait();
                System.out.println(Thread.currentThread().getName() + " 等待结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable r = new WaitNotifyAll();
        Thread threadA = new Thread(r);
        Thread threadB = new Thread(r);

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceA) {
                    resourceA.notifyAll();
                    System.out.println("ThreadC notified");
                }
            }
        });

        threadA.start();
        threadB.start();

        Thread.sleep(200);

        threadC.start();

    }
}

在这里插入图片描述

  • 修改代码
    在这里插入图片描述
    在这里插入图片描述

1.1.3 只释放当前monitor展示

  • 执行wait这个方法的一定是一个对象，这个对象就代表那一把锁。哪一个对象执行wait，就是释放掉哪一个对象的锁，而不影响其他锁的行为
/**
 * @Description 证明wait只释放当前的那把锁
 * @Author tzb
 * @Date 2021/2/9 9:42
 * @Version 1.0
 **/
public class WaitNotifyReleaseOwnMonitor {

    private static volatile  Object resourceA = new Object();
    private static volatile  Object resourceB = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceA) {
                    System.out.println(" ThreadA got resourceA lock");
                    synchronized (resourceB) {
                        System.out.println("ThreadA got resourceB lock");
                    }

                    try {
                        resourceA.wait();
                        System.out.println(" ThreadA 释放 resourceA lock");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (resourceA) {
                    System.out.println(" ThreadB got resourceA lock");

                    synchronized (resourceB) {
                        System.out.println(" ThreadB got resourceB lock");
                    }
                }
            }
        });

        thread1.start();
        thread2.start();

    }
}

在这里插入图片描述

1.2 手写生产者和消费者设计模式

在这里插入图片描述
在这里插入图片描述

/**
 * @Description 用wait和notify实现
 * @Author tzb
 * @Date 2021/2/9 10:11
 * @Version 1.0
 **/
public class ProducerConsumerModel {
    public static void main(String[] args) {
        EventStorage eventStorage = new EventStorage();
        Producer producer = new Producer(eventStorage);
        Consumer consumer = new Consumer(eventStorage);

        new Thread(producer).start();
        new Thread(consumer).start();

    }
}

class Producer implements Runnable {

    private EventStorage storage;

    public Producer(EventStorage storage) {
        this.storage = storage;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            storage.put();
        }
    }
}

class Consumer implements Runnable {

    private EventStorage storage;

    public Consumer(EventStorage storage) {
        this.storage = storage;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            storage.take();
        }
    }
}

class EventStorage {
    private int maxSize;
    private LinkedList<Date> storage;

    public EventStorage() {
        maxSize = 10;
        storage = new LinkedList<>();
    }

    public synchronized void put() {

        while (storage.size() == maxSize) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        storage.add(new Date());
        System.out.println("仓库里有" + storage.size() + " 个产品");
        // 呼唤沉睡的消费者
        notify();
    }

    public synchronized void take() {
        while (storage.size() == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("拿到了" + storage.poll() + ",仓库剩下 " + storage.size());
        notify();
    }
}


仓库里有1 个产品
仓库里有2 个产品
仓库里有3 个产品
仓库里有4 个产品
仓库里有5 个产品
仓库里有6 个产品
仓库里有7 个产品
仓库里有8 个产品
仓库里有9 个产品
仓库里有10 个产品
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 9
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 8
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 7
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 6
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 5
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 4
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 3
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 2
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 1
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 0
仓库里有1 个产品
仓库里有2 个产品
仓库里有3 个产品
仓库里有4 个产品
仓库里有5 个产品
仓库里有6 个产品
仓库里有7 个产品
仓库里有8 个产品
仓库里有9 个产品
仓库里有10 个产品
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 9
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 8
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 7
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 6
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 5
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 4
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 3
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 2
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 1
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 0
仓库里有1 个产品
仓库里有2 个产品
仓库里有3 个产品
仓库里有4 个产品
仓库里有5 个产品
仓库里有6 个产品
仓库里有7 个产品
仓库里有8 个产品
仓库里有9 个产品
仓库里有10 个产品
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 9
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 8
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 7
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 6
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 5
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 4
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 3
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 2
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 1
拿到了Tue Feb 09 14:11:28 CST 2021,仓库剩下 0

1.3 wait,notify,notifyAll常见的面试问题

1.3.1 两个线程交替打印0-100奇偶数

  • 方式1： synchronized,存在浪费的情况
/**
 * @Description 两个线程交替打印0-100的奇偶数，
 * synchronized实现
 * @Author tzb
 * @Date 2021/2/9 14:18
 * @Version 1.0
 **/
public class WaitNotifyPrintOddEvenSyn {

    private static int count;

    private static final Object lock = new Object();

    // 新建2个线程，1个只处理偶数，另一个只处理奇数（位运算）
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (count < 100) {
                    synchronized (lock) {
                        if ((count & 1) == 0) {
                            System.out.println(Thread.currentThread().getName() + " : " + count);
                            count++;
                        }
                    }
                }
            }
        },"偶数").start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (count < 100) {
                    synchronized (lock) {
                        if ((count & 1) == 1) {
                            System.out.println(Thread.currentThread().getName() + " : " + count);
                            count++;
                        }
                    }
                }
            }
        },"奇数").start();
    }

}

在这里插入图片描述

  • 方式2： wait/notify
/**
 * @Description 证明wait只释放当前的那把锁
 * @Author tzb
 * @Date 2021/2/9 9:42
 * @Version 1.0
 **/
public class WaitNotifyPrintOddEven {

    private static int count = 0;

    private static final Object lock = new Object();


    //1.拿到锁，就打印
    //2.打印完，唤醒其他线程，自己就休眠
    static class TurningRunner implements Runnable {
        @Override
        public void run() {
            while (count <= 100) {
                // 拿到锁就打印
                synchronized (lock) {
                    System.out.println(Thread.currentThread().getName() + ":" + count++);
                    lock.notify();
                    if (count <= 100) {
                        try {
                            //如果任务还没有结束，就让出当前的锁，并休眠
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new TurningRunner(),"偶数").start();
        Thread.sleep(100);
        new Thread(new TurningRunner(),"奇数").start();

    }

}

1.3.2 手写生产者和消费者模式

1.3.3 wait需要在同步代码块使用，而sleep不需要

  • 为了使得通信可靠，防止死锁或者永久的等待

1.3.4 为什么线程通信的方法 wait，notify，notifyAll定义在Object,sleep定义在 Thread

  • wait，notify，notifyAll 是锁级别的操作，锁是属于某一个对象，不是在线程中，

1.3.5 wait方法是属于Object对象的，调用 Thread.wait会怎样？

  • Thread也可以当做普通的锁，但是 Thread类比较特殊，在线程退出的时候会自动执行 notify，会扰乱自己设计的流程。

1.3.6 notify和notifyAll的选取

1.3.7 notifyAll之后所有的线程都会再次抢夺锁，如果某线程抢夺失败怎么样？

  • 回到最初始的状态

1.3.8 用 suspend和resume来阻塞线程可以吗？

  • 不推荐，存在线程安全问题
一角残叶
关注
专栏目录
深入浅出Java多线程.pdf
04-27
综上所述，《深入浅出Java多线程.pdf》覆盖了Java多线程从基础知识到高级特性的各个方面，适合于想要深入理解Java多线程机制的开发人员阅读。无论是初学者还是有一定经验的开发者，都能从中获得宝贵的理论知识和实践...
sleep方法详解（慕课网 -＞ 线程八大核心+Java并发底层原理精讲 掌握企业级并发问题解决方案）
weixin_44745208的博客
08-15 280
作用：我只想让线程在预期的时间执行，其他时间不要占用CPU资源 讲讲sleep方法的特点？ sleep方法可以让线程进入Timed_Waiting状态，并且不占用CPU资源，但是不释放锁（包括synchronize和lock），直到规定时间后再执行，休眠期间如果被中断，会抛出异常并清除中断状态。 1、sleep不释放synchronized的Monitor package threadcoreknowledge.threadobjectclasscommonmethods; /** * 展示线程sl
wait作用和用法（慕课网 -＞ 线程八大核心+Java并发底层原理精讲 掌握企业级并发问题解决方案）
weixin_44745208的博客
08-11 371
阻塞阶段 有的时候我们想让一个线程或多个线程暂时去休息一下-> wait()：使线程进入到阻塞状态，等到我们后续需要它的时候，条件成熟的时候再唤醒它 -> notify()、notifyAll()：唤醒被阻塞的线程，等待CPU调度。值得注意的一点是：在执行wait()方法前必须先拿到这个对象的monitor锁   当线程拿到进入阻塞状态后 1、直至以下四种情况发生时，才会被唤醒 另一个线程调用这个对象的notify()方法且刚好被唤醒的是本线程 另一个线程调用这个对象的notify(
开启多线程启动的新世界（慕课网 -＞ 线程八大核心+Java并发底层原理精讲 掌握企业级并发问题解决方案）
weixin_44745208的博客
07-26 192
start()和run()对比 package threadcoreknowledge.startthread; public class StartAndRunMethod { public static void main(String[] args) { Runnable runnable = () -> { System.out.println(Thread.currentThread().getName()); };
线程各属性（慕课网 -＞ 线程八大核心+Java并发底层原理精讲 掌握企业级并发问题解决方案）
weixin_44745208的博客
09-08 184
yield方法详解（慕课网 -＞ 线程八大核心+Java并发底层原理精讲 掌握企业级并发问题解决方案）
weixin_44745208的博客
08-15 193
yield释放CPU资源还是处于Runnable状态，不会进入Waiting或Blocked状态，随时有可能会再次被调度，不同于sleep，sleep会先进入到阻塞状态，还有一点是JVM不保证遵循，如：当CPU资源充足情况下，调用yield不一定就会释放CPU时间片。 ...
深入浅出 Java 多线程.pdf_java_
10-03
Java多线程是Java编程中的核心概念，尤其在如今并发性能至关重要的软件开发中，它的重要性不言而喻。深入理解Java多线程能够帮助开发者有效地利用计算机资源，提高程序的执行效率，优化系统性能。 Java多线程的实现...
深入浅出java多线程代码示例
06-29
本文将深入浅出地探讨Java多线程的相关知识点，通过具体代码示例帮助你理解和掌握这一核心技能。 一、线程的创建与启动 在Java中，有三种方式创建线程：实现Runnable接口、继承Thread类以及使用ExecutorService。`...
深入浅出Java多线程.doc
06-09
Java多线程是Java编程中的核心概念，尤其在并发编程中不可或缺。本文将深入探讨Java多线程中的`join()`方法，以及它在实际开发中的应用。 `join()`方法是Java线程同步的一种机制，主要用于控制线程的执行顺序。在...
浅谈Java线程并发知识点
08-31
Java线程并发是多线程环境...总的来说，Java线程并发是一个复杂而深入的主题，涉及多线程编程的多个方面，包括同步、并发容器、通信机制和同步器。理解和熟练应用这些知识点对于编写高效、可靠的并发Java程序至关重要。
实现多线程的正确姿势（慕课网 -＞ 线程八大核心+Java并发底层原理精讲 掌握企业级并发问题解决方案）
weixin_44745208的博客
07-26 325
实现多线程的方法是1种还是2种还是4种？ 网上的说法 。。。。。。。 正确的说法 实现多线程的官方正确方法：2种 方法一：实现Runnable接口 package threadcoreknowledge.createthreads; public class RunnableStyle implements Runnable{ public static void main(String[] args) { Thread thread = new Thread(new Runna
线程8大核心基础知识【1】-- 实现多线程的方法
weixin_42865375的博客
05-04 335
这些问题都是面试常考问题。跟我一起学习，一起攻破Java并发吧！ 为了能拿到offer，为了美好生活，为了明天，加油！ 1.实现多线程的方法有1种2种还是4中？ 百度搜索一下先：在此图中有2种，3种，4种各不相同，鱼龙混杂 那到底为有几种呢？答案是2种，一些人又质疑了，凭啥信你？不权威！ 辩论：Oracle官网的文档是如何写的呢？这就很权威了吧！ Oracle官网的文档是如何写的？ 方法一...
线程八大核心基础
技术分享，读书笔记，面试宝典，算法积累，应有尽有～
03-03 744
实现多线程的方法到底有1种还是2种还是4种？ 怎样才是正确的线程启动方式？ 如何正确停止线程？（一） 如何正确停止线程？（二） 线程的6个状态（生命周期） Thread和Object类中的重要方法详解 线程的各个属性 未捕获异常如何处理？ 双刃剑：多线程会导致的问题
第二章、线程八大核心基础知识
Coder
06-21 244
线程八大核心
AllenXmh的博客
03-30 543
线程八大核心1实现多线程的方法有哪几种怎么样才是正确的线程启动方式如何正确停止线程（重点、难点）线程的一生——6个状态（生命周期）Thread和Object类中的重要方法线程的各个属性未捕获异常如何处理多线程会导致的问题 1 实现多线程的方法有哪几种 怎么样才是正确的线程启动方式 如何正确停止线程（重点、难点） 线程的一生——6个状态（生命周期） Thread和Object类中的重要方法 线程的各个属性 未捕获异常如何处理 多线程会导致的问题 ...
多线程八大核心知识体系笔记-1.线程创建的方式分析
xingzhes_的博客
12-12 401
目录线程基础多线程创建方式正确的理解Oracle官网验证两种实现方法方法一：实现Runnable接口，重写run()函数，运行start()方法（代码展示）方法二：继承Thread类，重写run()函数，运行start()方法（代码展示）两种方法的对比方法1（实现Runnable接口）更好的三个优势1.解耦性好，run方法业务与线程建立逻辑分离2.节约资源，每次新建任务无需每次都新建线程，例如线程池类3.可扩展性好，可用实现多继承接口，不能实现多继承类两种方法的本质对比1.Runnable整个run方法被重
Java核心技术（第8版）学习笔记_多线程
HOLLY_Worm的专栏
03-22 1580
第14章 多线程多线程和多进程的本质区别在于，每个进程拥有自己的一整套变量，而线程则共享数据。与进程相比，线程通常更轻量级。创建/撤销一个线程比启动新进程的开销要小得多
多线程的三大核心
sheepherder
07-29 784
原子性 一系列操作要么成功，要么失败，不存在其中的一部分成功了，一部分失败，和数据库的原子性差不多 正例 public int getState() { return state; } 多线程的情况下，不管那个线程获取到state都是1 反例 public void stateIncrement() { state++; } 这里涉及三个操作 先获取state的值 再对sta...
Java中用到的线程调度
方法属性类，一个都不会
03-09 494
抢占式调度： 抢占式调度指的是每条线程执行的时间、线程的切换都由系统控制，系统控制指的是在系统某种 运行机制下，可能每条线程都分同样的执行时间片，也可能是某些线程执行的时间片较长，甚至 某些线程得不到执行的时间片。在这种机制下，一个线程的堵塞不会导致整个进程堵塞。 协同式调度： 协同式调度指某一线程执行完后主动通知系统切换到另一线程上执行，这种模式就像接力赛一样， 一个人跑完自己的路程就把接力棒...
安琪拉详解Java并发编程：多线程基础
在Java并发编程中，多线程是核心概念之一，它允许程序同时执行多个任务，从而提高了处理能力。线程是操作系统调度的基本单位，而进程则是拥有独立内存空间和资源的执行实体。在Java中，我们可以通过两种主要方式来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值