黑马程序员-多线程部分（三.等待唤醒机制）

最新推荐文章于 2024-10-12 12:34:26 发布
原创 最新推荐文章于 2024-10-12 12:34:26 发布 · 393 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了线程间同步和通信的基本概念，通过具体案例详细解释了如何使用synchronized关键字和Lock接口实现线程间的等待-通知机制，有效解决多线程环境下资源共享问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

　——- android培训、java培训、期待与您交流！ ———-

对于操作同一资源的不同行为，该如何解决？

思路：因为两个线程操作的是同一资源，为避免出现数据安全问题，必须实现同步，且设置的同步锁对象一致，由于是两个线程的两种行为，可以将资源类名.class作为同步锁传入。

例子一：一边输入姓名和性别，一边输出。
定义资源类，包括姓名，性别，两个属性。

class Resource
{
     String name;
     String sex;
}

输入类，实现Runnable接口，作用，轮流输入两个人的姓名和性别。

class Input implements Runnable
{   private Resource resource;
    public Input(Resource resource)
    {
        this.resource = resource;
    }

    public void run()
    {   int i=1;
        while(true)
        {
            if(i%2==0)
            {
                resource.name = "mack";
                resource.sex = "male";  
            }else
            {
                resource.name = "莉莉";
                resource.sex = "女女女女女女";
            }
            i++;
        }

    }
}

输出类：实现Runnable接口，作用，输出资源里的姓名和性别。

class Output implements Runnable
{   private Resource resource;
    public Output(Resource resource)
    {
        this.resource = resource;
    }

    public void run()
    {   while(true)
        {
            System.out.println(resource.name+"....."+resource.sex);
        }

    }
}

在主函数中实例化并调用两个线程

public class ThreadDemo
{
    public static void main(String args[])
    {
        Resource resource = new Resource();
        Input input = new Input(resource);
        Output out = new Output(resource);
        Thread t1 = new Thread(input);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();
    }
}

在未执行同步操作之前，输出结果为：
这里写图片描述
发现出现了数据异常，并没有同步输出对应的名字和性别。因此需要使用同步。
同步之后代码块如下：

class Input implements Runnable
{   private Resource resource;
    public Input(Resource resource)
    {
        this.resource = resource;
    }

    public void run()
    {   int i=1;
        while(true)
        {
            synchronized(Resource.class)
            {
                if(i%2==0)
                {
                    resource.name = "mack";
                    resource.sex = "male";  
                }else
                {
                    resource.name = "莉莉";
                    resource.sex = "女女女女女女";
                }
                i++;
            }

        }

    }
}


class Output implements Runnable
{   private Resource resource;
    public Output(Resource resource)
    {
        this.resource = resource;
    }

    public void run()
    {   while(true)
        {
            synchronized(Resource.class)
            {
                System.out.println(resource.name+"....."+resource.sex);
            }
        }

    }
}

运行结果如下：
这里写图片描述

应用同步解决了数据混乱的问题。
但是输出方式却是连着输出，而不符合轮流输出的效果。此时需要在输入之后，让输入线程等待，让输出线程取出之后，唤醒输入线程，同时输出线程等待，如此循环，能到达轮流输出的效果。

这就是重点：

线程间的通信，等待唤醒机制

（一）利用Synchronized同步来实现

修改上述代码：
共享资源项：

class Resource
{
     String name;
     String sex;
     boolean flag = true;
}

输入：

class Input implements Runnable
{   private Resource resource;
    public Input(Resource resource)
    {
        this.resource = resource;
    }

    public void run()
    {   int i=1;
        while(true)
        {
            synchronized(Resource.class)
            {   if(resource.flag)
                {
                    try{Resource.class.wait();}catch(Exception e){}
                }
                if(i%2==0)
                {
                    resource.name = "mack";
                    resource.sex = "male";  
                }else
                {
                    resource.name = "莉莉";
                    resource.sex = "女女女女女女";
                }
                i++;
                resource.flag = true;
                Resource.class.notify();
            }

        }

    }
}

输出：

class Output implements Runnable
{   private Resource resource;
    public Output(Resource resource)
    {
        this.resource = resource;
    }

    public void run()
    {   while(true)
        {
            synchronized(Resource.class)
            {   
                if(!resource.flag)
                {
                    try{Resource.class.wait();}catch(Exception e){}
                }
                System.out.println(resource.name+"....."+resource.sex);
                resource.flag = false;
                Resource.class.notify();
            }
        }
    }
}

运行结果如下：
这里写图片描述

现在实现了轮流输出的效果。

上面讲述的是一个输入一个输出，假如两个生成者，两个消费者，看看结果如何？

例子二：两个生成者，两个消费者，开启四个线程。

class Resource
{
    private String name;
    private int count;
    boolean flag = true;
    public synchronized void set(String name)
    {   
        if(flag)
        {
            try{this.wait();}catch(Exception e){}
        }
        this.name = name+"......."+count++;
        System.out.println(Thread.currentThread().getName()+".....生产者...."+this.name);
        flag = true ;
        this.notify();
    }
    public synchronized void out()
    {   
        if(!flag)
        {
            try{this.wait();}catch(Exception e){}
        }
        System.out.println(Thread.currentThread().getName()+".....消费者...."+this.name);
        flag = false ;
        this.notify();
    }
}

class Producer implements Runnable
{
    private Resource resource;
    public Producer(Resource resource)
    {
        this.resource = resource;
    }
    public void run()
    {
        while(true)
        {
            resource.set("张三");
        }

    }
}
class Consumer implements Runnable
{
    private Resource resource;
    public Consumer(Resource resource)
    {
        this.resource = resource;
    }
    public void run()
    {
        while(true)
        {
            resource.out();
        }

    }
}

public class ProducerConsume
{
    public static void main(String args[]) throws Exception
    {
        Resource resource = new Resource();
        Producer pro = new Producer(resource);
        Consumer con = new Consumer(resource);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行结果如下：
这里写图片描述
可以看出：出现了问题，当生产者生产出好几个，但是消费者都未消费掉，是因为当第一个生产者生产完，首先被唤醒的是第二个生产者，而它未经过判断标志位就开始生产，从而产生了这种情况。

修改办法：
1）把Resource类中同步函数部分中，把if换成while（避免唤醒后不用判断）；
2）而用whlie可以实现循环判断，四个线程会同时出现等待状态，为避免这种情况，修改notify为notifyAll来实现。

class Resource
{
    private String name;
    private int count;
    boolean flag = true;
    public synchronized void set(String name)
    {   
        while(flag)
        {
            try{this.wait();}catch(Exception e){}
        }
        this.name = name+"......."+count++;
        System.out.println(Thread.currentThread().getName()+".....生产者...."+this.name);
        flag = true ;
        this.notifyAll();
    }
    public synchronized void out()
    {   
        while(!flag)
        {
            try{this.wait();}catch(Exception e){}
        }
        System.out.println(Thread.currentThread().getName()+".....消费者...."+this.name);
        flag = false ;
        this.notifyAll();
    }
}

运行结果如下：
这里写图片描述

（二）JDK1.5之后Lock类

JDK1.5之后同步的新优点：
第一点：把隐性的synchronized同步锁变成了可见的Lock代替，上锁lock和解锁unlock。
第二点：把Object（可操作wait，notify，notifyAll）同步锁换成了Condition接口（await，signal，signalAll），此接口可以通过Lock类获得newCondition。
第三点：最大的优点，一个锁同时可以拥有许多个condition对象，可以有选择性的唤醒个别线程。
备注：必须注意同步最后需要解锁，此类最大的好处是只定义一个锁，就可以有好几个condition，避免了synchronized定义多个锁引起的同步嵌套，避免了死锁的问题。实现了只唤醒对方线程的优点。
例子：改写上述两个生产和两个消费过程的实例，

import java.util.concurrent.locks.*;

class Resource
{
    private String name;
    private int count;
    Lock lock = new ReentrantLock();
    Condition conditionPro = lock.newCondition();
    Condition conditionCon = lock.newCondition();
    boolean flag = true;
    public void set(String name) throws Exception
    {   
        lock.lock();
            try
            {   
                while(flag)
                conditionPro.await();
                this.name = name+"......."+count++;
                System.out.println(Thread.currentThread().getName()+".....生产者...."+this.name);
                flag = true ;
                conditionCon.signal();
            }finally
            {
                lock.unlock();
            }


    }
    public void out() throws Exception
    {   
        lock.lock();
            try
            {
                while(!flag)
                    conditionCon.await();
                System.out.println(Thread.currentThread().getName()+".....消费者...."+this.name);
                flag = false ;
                conditionPro.signal();
            }finally
            {
                lock.unlock();
            }

    }
}

运行结果如下：
这里写图片描述

完美的解决了问题。比起synchronized更直观，更清楚的让人理解。

黑马程序员--等待唤醒机制
H_ello_world的专栏
01-25 491
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 等待唤醒机制 重点：用while和notifyAll的情况；当多个生产者和消费者同时在做同一件事时必须使用(多个线程同时操作)。 notifyAll多个线程同时操作一个函数时直接把所有线程唤醒。当唤醒本方线程时因为是while所以先判断条件之后才往下执行代码。 if和while区
黑马程序员-----多线程
cui1kcan2的博客
05-16 632
多线程
黑马程序员——多线程
dengfeifei258369的专栏
05-03 246
---------------------- android培训、java培训、期待与您交流！ ---------------------- 一、进程    进程是在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。 二、线程     线程是进程中的一个独立的控制单元，线程在控制着进程的执行。一个进程中至少有一个线程。 三、自定义多线程
黑马程序员java学习—多线程2：等待唤醒机制
fangke713的专栏
06-04 683
同步函数： 只有当同步代码块和同步函数封装的内容是一样的时候，才可以直接将同步关键字作为修饰符修饰函数即可。 这样函数就具备了同步性。 这就是同步函数。同步的另一种表现形式。 这种表现形式较为简单。 同步函数使用锁是this 。是调用同步函数的对象。 同步函数和同步代码块有什么区别呢？ 1，同步函数比同步代码块写法简单。 2，同步函数使用的锁是this。同步代码块使用的锁是
黑马程序员_多线程等待唤醒机制简单入门
sihei的专栏
08-09 697
多线程等待唤醒机制简单入门               听完毕老师讲解的等待唤醒机制的原理。自己进行了简单的整理。           线程之间的关系是平等的，彼此之间并不存在任何依赖，它们各自竞争CPU资源，互不相让，并且还无条件地阻止其他线程对共享资源的异步访问。等待唤醒机制如图讲解               等待唤醒机制在开发中是经常用到的。两个线程去共享一个资源，一个线
黑马程序员_多线程的死锁和等待唤醒机制
任黎明的专栏
07-02 694
------- android培训、java培训、期待与您交流！ ----------
黑马程序员-多线程部分（二.线程同步）
qq_30468305的博客
10-12 580
我们知道，多线程带来了方便，但同时也出现数据安全问题。 看如下买票的例子：class Test implements Runnable { private int ticket = 500; public void run() { while(true) { if(ticket>0) {
多线程的等待唤醒机制的自我理解
热门推荐
温柔半两，从容一生
03-29 12万+
我们假设有生产者和消费者用桌子上的共享数据控制线程的执行消费者先拿到CPU的执行权 就会wait生产者后拿到CPU的执行权 唤醒消费者生产者等待是因为没有消费者生产者先抢到CPU的执行权然后等待消费者然后消费者没有出现 生产者又抢到了CPU的执行权就会wait。
黑马程序员-多线程
sa_leon的博客
08-12 449
——- android培训、java培训、期待与您交流！ ———-1.1 进程和线程进程：正在进行中的程序（直译）。 线程：进程中一个负责程序执行的控制单元（执行路径）。 一个进程中可以有多个执行路径，称之为多线程。 一个进程中至少要有一个线程。 开启多个线程是为了同时运行多部分代码，每一个线程都有自己运行的内容P.S.一个进程中有多个线程，称为多线程。 思考：jvm启动是单线程还是多线
【黑马java基础】多线程
YOLO的博客
07-25 735
线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。比如：取钱的线程安全问题（场景：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，如果小明和小红同时来取钱，并且2人各自都在取钱10万元，可能会出现什么问题呢？①小明线程步骤一先判断余额是否够，够②小红线程步骤一先判断余额是否够，够③因为小明线程判断够，所以银行吐出10万④银行账户更新为0元⑤因为小红线程判断够，所以银行吐出10万⑥银行账户更新为-10万元结果：2人都取钱10万，银行亏了10万。
黑马程序员入学面试题
08-28
- `wait()`：是Object类的一个方法，用于使线程等待直到被唤醒或超时。通常与synchronized一起使用，在等待期间释放锁资源。 - `sleep()`：是Thread类的一个静态方法，使当前正在执行的线程暂停指定的时间。不会释放...
RocketMQ学习笔记五（黑马）大神级
2301_81298401的博客
03-15 489
/创建主题//根据时间戳从队列中查找消息偏移量//查找消息队列中最大的偏移量//查找消息队列中最小的偏移量//根据偏移量查找消息//根据条件查找消息//根据消息ID和主题查找消息//启动//关闭//查找该主题下所有消息//同步发送消息//同步超时发送消息//异步发送消息//异步超时发送消息//发送单向消息//选择指定队列同步发送消息//选择指定队列异步发送消息//选择指定队列单项发送消息//批量发送消息。
黑马程序员-redis项目实践笔记2
水w的博客
10-12 1002
黑马程序员-redis项目实践笔记2
中孚密保卫士是由中孚信息股份有限公司开发的一款信息安全产品，主要用于终端计算机的保密管理和数据防泄漏 它主要面向政府机关、军工单位、科研院所等对信息安全有较高要求的涉密单位，帮助其实现对涉密信息的全
08-14
终端保密管理：对计算机终端的操作行为进行监控和审计，防止违规外联、非法拷贝、打印、截屏等行为。 数据防泄漏（DLP）：通过内容识别、加密、权限控制等手段，防止敏感或涉密数据通过U盘、网络、邮件等途径泄露。 文件加密与权限控制：对涉密文件进行透明加密，确保文件在授权范围内使用，防止未授权人员查看或传播。 行为审计与日志记录：详细记录用户的操作行为（如文件访问、外发、打印等），便于事后追溯和审计。 违规外联监控：防止涉密计算机违规连接互联网或其他非授权网络，保障网络边界安全。 移动存储介质管理：对U盘、移动硬盘等设备进行授权管理，区分普通盘和专用盘，防止非法数据拷贝。
Python批量发送短信验证码的实现方法.doc
08-14
Python批量发送短信验证码的实现方法.doc
信号处理领域中经验模态分解(EMD)对复杂信号进行IMF分量提取与应用
最新发布
08-14
内容概要：本文介绍了经验模态分解（EMD）这一强大的信号处理技术，详细解释了EMD如何将复杂信号分解为多个内在模态函数（IMF）分量，从而揭示信号的局部特征。文中不仅提供了理论背景介绍，还给出了具体的Python代码实例，展示了EMD在去除心电图基线漂移和分析多层信号方面的实际应用场景。同时指出了EMD存在的局限性和优化方法，如边界效应和模态混叠问题及其解决方案。 适合人群：从事信号处理相关工作的研究人员和技术人员，尤其是对非平稳信号处理感兴趣的从业者。 使用场景及目标：适用于需要从复杂信号中提取有用信息的各种场合，如金融数据分析、生物医学工程等领域。目标是帮助读者掌握EMD的基本原理和具体应用，提高处理非平稳信号的能力。 阅读建议：建议读者结合提供的代码片段动手实践，深入理解EMD的工作机制以及如何针对不同类型的数据选择合适的参数设置。
神经网络基础知识的入门教学指南
08-14
资源下载链接为： https://pan.quark.cn/s/4a0cf578c0a4 神经网络基础知识的入门教学指南（最新、最全版本！打开链接下载即可用！）
C++ 编程语言实现的神经网络库
08-14
资源下载链接为： https://pan.quark.cn/s/5ded706c7f1c C++ 编程语言实现的神经网络库（最新、最全版本！打开链接下载即可用！）
双闭环永磁同步电机调速系统SVPWM控制的仿真研究与参数优化 · SVPWM
08-14
内容概要：本文详细探讨了双闭环永磁同步电机调速系统的SVPWM控制方法及其仿真实现。首先介绍了主电路配置和控制系统的架构，包括电流内环和转速外环的设计，以及PI调节器的具体实现方式。文中展示了关键代码片段，如电流环内的PI调节器和SVPWM的扇区判断算法，并深入讨论了参数设定对系统性能的影响。针对实际仿真中遇到的问题，如转矩脉动和波形畸变，提出了有效的解决方案，如调整作用时间和提高采样频率。最终通过对波形数据的细致分析验证了改进措施的有效性。 适合人群：从事电机控制、电力电子领域的研究人员和技术人员，尤其是对SVPWM控制和双闭环系统感兴趣的读者。 使用场景及目标：适用于需要深入了解和掌握双闭环永磁同步电机调速系统SVPWM控制原理及其实现的技术人员。目标是在理论基础上进行实际操作，优化系统参数，提升调速精度和平稳度。 其他说明：本文不仅提供了详细的理论解释，还有具体的代码实例和实验数据支持，有助于读者更好地理解和应用相关技术。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值