同步模式之保护性暂停、异步模式之生产者/消费者

最新推荐文章于 2024-05-16 10:23:10 发布
最新推荐文章于 2024-05-16 10:23:10 发布
阅读量140 收藏 1
点赞数 2
分类专栏： Java并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZSA222/article/details/123387314
版权

文章目录

1.同步模式之保护性暂停

1.1 概述

即 Guarded Suspension， 用在一个线程等待另一个线程的执行结果

  • 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject
  • 如果有结果不断从一个线程到另一个线程 那么可以使用消息队列（见生产者/消费者）
  • JDK 中，join 的实现、Future 的实现，采用的就是此模式
  • 因为要等待另一方的结果，因此归类到同步模式

在这里插入图片描述

1.2 实现

一个线程需要等待另一个线程的执行结果

/**
 * 多线程同步模式 - 一个线程需要等待另一个线程的执行结果
 */
@Slf4j(topic = "GuardeObjectTest")
public class GuardeObjectTest {
    public static void main(String[] args) {

        // 线程1等待线程2的下载结果
        GuardeObject guardeObject = new GuardeObject();

        new Thread(() -> {
            log.debug("等待结果");
            Object obj = guardeObject.get();
            log.debug("结果:{}", obj.toString());
        }, "t1").start();

        new Thread(() -> {

            log.debug("执行下载");
            String result = "下载成功";
            guardeObject.complete(result);
            // 可以继续执行别的任务

        }, "t2").start();
    }
}


class GuardeObject {

    // 结果
    private Object response;

    // 获取结果
    public Object get() {
        synchronized (this) {
            // 防止虚假唤醒
            // 没有结果
            while (response == null) {
                try {
                    // 释放锁
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            // 给结果变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}

运行结果

2022-03-09 21:19:32 [t1] - 等待结果
2022-03-09 21:19:32 [t2] - 执行下载
2022-03-09 21:19:32 [t1] - 结果:下载成功

Process finished with exit code 0

增强超时效果

/**
 * 多线程同步模式 - 一个线程需要等待另一个线程的执行结果
 */
@Slf4j
public class GuardeObjectTest {

    public static void main(String[] args) {
        // 线程1等待线程2的下载结果
        GuardeObject guardeObject = new GuardeObject();

        new Thread(() -> {
            log.debug("begin");
            Object obj = guardeObject.get(2000);
            log.debug("结果是:{}", obj);
        }, "t1").start();


        new Thread(() -> {
            log.debug("begin");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            guardeObject.complete("hello word");
        }, "t2").start();
    }
}

class GuardeObject {
    // 结果
    private Object response;

    // 获取结果
    // timeout表示等待多久. 这里假如是2s
    public Object get(long timeout) {
        synchronized (this) {
            // 假如开始时间为 15:00:00
            long begin = System.currentTimeMillis();
            // 经历的时间
            long passedTime = 0;
            while (response == null) {
                // 这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过了最大等待时间, 退出循环
                if (waitTime <= 0) {
                    break;
                }
                try {
                    // this.wait(timeout)的问题: 虚假唤醒在15:00:01的时候,此时response还null, 此时经历时间就为1s,
                    // 进入while循环的时候response还是空,此时已经经历了1s,
                    // 所以只要再等1s就可以了. 所以等待的时间应该是 超时时间(timeout) - 经历的时间(passedTime)
                    this.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 经历时间
                passedTime = System.currentTimeMillis() - begin; // 15:00:02
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            // 给结果变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}

运行结果

// 超时
2022-03-09 21:57:07 [t1] - begin
2022-03-09 21:57:07 [t2] - begin
2022-03-09 21:57:09 [t1] - 结果是:null

Process finished with exit code 0

// 没有超时
2022-03-09 21:58:29 [t2] - begin
2022-03-09 21:58:29 [t1] - begin
2022-03-09 21:58:30 [t1] - 结果是:hello word

Process finished with exit code 0

1.3 join原理

join源码
synchronized在join方法上，在主线程therd1.join锁的对象是therd1，线程对象作为锁运行完后会自动唤醒在它上面wait的主线程

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
        	// 该线程存活就一直等待， 存活：true
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

1.4 扩展-多任务版

图中Futures就好比居民楼一层的信箱（每个信箱有房间编号)，左侧的t0， t2， t4就好比等待邮件的居民， 右侧的t1， t3， t5就好比邮递员

如果需要在多个类之间使用GuardedObject 对象，作为参数传递不是很方便，因此设计一个用来解耦的中间 类，这样不仅能够解耦【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理

在这里插入图片描述

/**
 * Description: 同步模式保护性暂停模式 (多任务版)
 */
@Slf4j
class GuardedObjectTest {
    public static void main(String[] args) throws InterruptedException {

        for (int i = 0; i < 3; i++) {
            new People().start();
        }

        Thread.sleep(1000);
        for (Integer id : Mailboxes.getIds()) {
            new Postman(id, "内容" + id).start();
        }
    }
}

@Slf4j
class People extends Thread {
    @Override
    public void run() {
        // 收信
        GuardedObject guardedObject = Mailboxes.createGuardedObject();
        log.debug("开始收信 id:{}", guardedObject.getId());
        Object mail = guardedObject.get(5000);
        log.debug("收到信 id:{}, 内容:{}", guardedObject.getId(), mail);
    }
}

@Slf4j
// 邮寄员类
class Postman extends Thread {
    private int id;
    private String mail;

    public Postman(int id, String mail) {
        this.id = id;
        this.mail = mail;
    }

    @Override
    public void run() {
        GuardedObject guardedObject = Mailboxes.getGuardedObject(id);
        log.debug("送信 id:{}, 内容:{}", id, mail);
        guardedObject.complete(mail);
    }
}

// 信箱类
class Mailboxes {
    private static Map<Integer, GuardedObject> boxes = new Hashtable<>();

    private static int id = 1;

    // 产生唯一 id
    private static synchronized int generateId() {
        return id++;
    }

    public static GuardedObject getGuardedObject(int id) {
        // 根据id获取到box并删除对应的key和value,避免堆内存爆了
        return boxes.remove(id);
    }

    public static GuardedObject createGuardedObject() {
        GuardedObject go = new GuardedObject(generateId());
        boxes.put(go.getId(), go);
        return go;
    }

    public static Set<Integer> getIds() {
        return boxes.keySet();
    }
}

// 用来传递信息的作用, 当多个类使用GuardedObject,就很不方便,此时需要一个设计一个解耦的中间类
class GuardedObject {
    // 标记GuardedObject
    private int id;
    // 结果
    private Object response;

    public int getId() {
        return id;
    }

    public GuardedObject(int id) {
        this.id = id;
    }

    // 获取结果
    // timeout表示等待多久. 这里假如是2s
    public Object get(long timeout) {
        synchronized (this) {
            // 假如开始时间为 15:00:00
            long begin = System.currentTimeMillis();
            // 经历的时间
            long passedTime = 0;
            while (response == null) {
                // 这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过了最大等待时间, 退出循环
                if (waitTime <= 0) {
                    break;
                }
                try {
                    // this.wait(timeout)的问题: 虚假唤醒在15:00:01的时候,此时response还null, 此时经历时间就为1s,
                    // 进入while循环的时候response还是空, 此时已经经历了
                    // 1s,所以只要再等1s就可以了. 所以等待的时间应该是 超时时间(timeout) - 经历的时间(passedTime)
                    this.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 经历时间
                passedTime = System.currentTimeMillis() - begin; // 15:00:02
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            // 给结果变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}

运行结果

2022-03-09 22:35:52 [Thread-2] - 开始收信 id:1
2022-03-09 22:35:52 [Thread-0] - 开始收信 id:3
2022-03-09 22:35:52 [Thread-1] - 开始收信 id:2
2022-03-09 22:35:53 [Thread-3] - 送信 id:3, 内容:内容3
2022-03-09 22:35:53 [Thread-4] - 送信 id:2, 内容:内容2
2022-03-09 22:35:53 [Thread-5] - 送信 id:1, 内容:内容1
2022-03-09 22:35:53 [Thread-1] - 收到信 id:2, 内容:内容2
2022-03-09 22:35:53 [Thread-2] - 收到信 id:1, 内容:内容1
2022-03-09 22:35:53 [Thread-0] - 收到信 id:3, 内容:内容3

Process finished with exit code 0

2.异步模式之生产者/消费者

2.1 概述

在这里插入图片描述

2.2 实现

/**
 * Description: 异步模式之生产者/消费者
 */
@Slf4j(topic = "z.ProductConsumerTest")
public class ProductConsumerTest {
    public static void main(String[] args) {
        MessageQueue queue = new MessageQueue(2);

        for (int i = 0; i < 3; i++) {
            int id = i;
            new Thread(() -> {
                queue.put(new Message(id, "值" + id));
            }, "生产者" + i).start();
        }

        new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message message = queue.take();
            }
        }, "消费者").start();
    }

}

// 消息队列类,在线程之间通信
@Slf4j(topic = "z.MessageQueue")
class MessageQueue {
    // 消息的队列集合
    private LinkedList<Message> list = new LinkedList<>();
    // 队列容量
    private int capcity;

    public MessageQueue(int capcity) {
        this.capcity = capcity;
    }

    // 获取消息
    public Message take() {
        // 检查队列是否为空
        synchronized (list) {
            while (list.isEmpty()) {
                try {
                    log.debug("队列为空, 消费者线程等待");
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 从队列头部获取消息并返回
            Message message = list.removeFirst();
            log.debug("已消费消息 {}", message);
            list.notifyAll();
            return message;
        }
    }

    // 存入消息
    public void put(Message message) {
        synchronized (list) {
            // 检查对象是否已满
            while (list.size() == capcity) {
                try {
                    log.debug("队列已满, 生产者线程等待");
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 将消息加入队列尾部
            list.addLast(message);
            log.debug("已生产消息 {}", message);
            list.notifyAll();
        }
    }
}

final class Message {
    private int id;
    private Object value;

    public Message(int id, Object value) {
        this.id = id;
        this.value = value;
    }

    public int getId() {
        return id;
    }

    public Object getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", value=" + value +
                '}';
    }
}

运行结果

2022-03-09 23:10:40 [生产者0] - 已生产消息 Message{id=0, value=值0}
2022-03-09 23:10:40 [生产者1] - 已生产消息 Message{id=1, value=值1}
2022-03-09 23:10:40 [生产者2] - 队列已满, 生产者线程等待
2022-03-09 23:10:41 [消费者] - 已消费消息 Message{id=0, value=值0}
2022-03-09 23:10:41 [生产者2] - 已生产消息 Message{id=2, value=值2}
2022-03-09 23:10:42 [消费者] - 已消费消息 Message{id=1, value=值1}
2022-03-09 23:10:43 [消费者] - 已消费消息 Message{id=2, value=值2}
2022-03-09 23:10:44 [消费者] - 队列为空, 消费者线程等待

Process finished with exit code 130 (interrupted by signal 2: SIGINT)
Zhang_960110
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程(四) : wait和notify原理、同步模式之保护性暂停、异步模式之生产者/消费者、park和unpark原理、线程状态转换
Guizy
01-06 2227
4.6 wait和notify 建议先看看wait和notify方法的javadoc文档 4.6.1同步模式之保护性暂停 即 Guarded Suspension，用在一个线程等待另一个线程的执行结果，要点： 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject 如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者） JDK 中，join 的实现、Future 的实现，采用的就是此模式 因为要等待另一方的结果，因此归类到同步模式 代码：Test22
生产消费者模式的C++实现
11-27
利用C++实现的生产消费者模式，每个生产者和消费者都在不同的线程中异步执行。
5、设计模式——同步模式之保护性暂停、join的原理、异步模式之生产者消费者模式
m0_45364328的博客
05-24 186
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言保护性暂停的定义简单实现增加超时等待join的原理扩展——保护性暂停模式的应用异步模式之生产者消费者模式 前言 上一章https://blog.csdn.net/m0_45364328/article/details/124936454 我们介绍了wait/notify的原理，为加深理解，我们本章介绍一下，由wait/notify延申出的设计模式 保护性暂停的定义 用一个线程等待另一个线程的执行结果 要点： 1、有一个结果.
java多线程编程 - 模式 -同步模式之保护性暂停模式
后端学习
03-19 93
同步模式之保护性暂停 即 Guarded Suspension，用在一个线程等待另一个线程的执行结果 要点 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject 如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者） JDK 中，join 的实现、Future 的实现，采用的就是此模式 因为要等待另一方的结果，因此归类到同步模式 实现 classGuardedObject { privateObjectresponse; private
Java多线程【5】异步模式之生产者消费者
wangleleb的博客
07-17 594
保护性暂停为同步，生产者消费者模式为异步模式。生产消费者模式维护一个list，生产者负责产生结果数据不关心数据如何处理，消费者之专心处理结果数据。生产者消费者模式运用的非常广泛，在mq消息队列中是使用进程级别的生产消费，这里的生产消费只是线程级别的，仅仅供读者进行理解和参考。https。...............
【JUC并发编程】异步模式之生产者/消费者
Decade_Faiz的博客
12-24 84
【代码】【JUC并发编程】异步模式之生产者/消费者。
Java多线程 异步模式之生产者消费者模式
LIUZEYU12A
01-31 337
之前学习过的同步模式是保护性暂停，存在一定的缺陷，我们当初举例是两个线程，线程A收信人，线程B送信人，使用一个信箱充当一个中间过渡的介质。在多任务的情况下，收信人存在多个，发信人就得存在多个，而且只有当送信者将信件送到指定的收信人手中，一个任务才算完成，这中间的操作是同步进行的，因此属于同步模式下的多线程任务。 弊端也很明显，实际情况下，送信者只需要把信件放入信箱通知收信人即可，而不需要等到收信人拿到信才算结束，因为送信人把信收到信箱通知收信人后还可以接着送下一份信件，这中间送信人的时间没有得到充分的利用。
java多线程 wait、notify详解 保护性暂停模式和生产者消费者模式
清风
01-17 777
概述 先来简单回顾一下管程Monitor，如上图Monitor的Owner是现在锁的持有者；EntryList是那些争抢锁但是没有争抢到的一些阻塞了的线程，线程的状态为BLOCKED；WaitSet里存放的则是曾经获得过锁，曾经是Monitor的Onwer，但是运行的时候条件不满足，只能先放弃锁的线程，WaitSet里面的线程的状态是WAITING或TIMED_WAITING状态(在操作系统层面这两种也是阻塞的)。 Owner线程发现条件不满足，调用wait方法，即可进入WaitSet变为WAI
《JUC并发编程 - 模式篇》保护性暂停模式 | 顺序控制模式 | 生产者消费者模式 | 两阶段终止模式 | Balking模式 | 享元模式
LXYDSF的博客
07-16 1138
《JUC并发编程 - 模式篇》保护性暂停模式 | 顺序控制模式 | 生产者消费者模式 | 两阶段终止模式 | Balking模式
同步模式异步模式
weixin_45511599的博客
06-03 231
定义： Guarded Suspension 用在一个线程等待另一个线程的执行结果要点： 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject如果有结果源源不断的从一个线程到另一个线程，可以使用消息队列（生产者消费者）JDK中join Future的实现，采用这个模式因为要等待另一方的结果，归类到同步模式 例子：线程一等待线程二的结果 优化： 不能无限制的等待 测试 最长等待2s 但是下载需要3s 等待两秒就不再等待了， 不需要产生结果和消费结果的线程一一对应 消费队列可
【项目】C++ 基于多设计模式下的同步&异步日志系统
一点一点变好
03-13 1290
前言 一般而言，业务的服务都是周而复始的运行，当程序出现某些问题时，程序员要能够进行快速的修复，而修复的前提是要能够先定位问题。 因此为了能够更快的定位问题，我们可以在程序运行过程中记录一些日志，通过这些日志我们便能够很容易地了解程序的运行状态，以及程序崩溃时的一些信息，有了这些信息我们便能够更好的定位问题以及分析问题了。 本项目代码地址：日志系统 C++ 基于多设计模式下的同步&异步日志系统前言日志系统的必要性项目相关介绍1、功能2、开发环境和工具3、核心技术4、环境搭建日志系统技
学习JavaScript设计模式之观察者模式
11-22
观察者模式（发布-订阅模式）：其定义对象间一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知。 在JavaScript中，一般使用事件模型来替代传统的观察者模式。 好处： （1）可...
详解ES6之async+await 同步/异步方案
08-29
主要介绍了详解ES6之async+await 同步/异步方案，本文以最简明的方式来疏通 async + await，有兴趣的可以了解下
JavaScript系列之―同步还是异步？
10-31
JavaScript系列之―同步还是异步？
C++实现生产者-消费者高效异步日志系统源码
06-13
C++的异步日志， 其特点是效率高（实测每秒支持125+万日志写入）、易拓展，尤其适用于频繁写日志的场景
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 442
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 138
借助jdeps分析出jar包的增量文件
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 521
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 204
java导出excel动态加载多sheet多复杂表头
labview生产者消费者模式
03-07
LabVIEW生产者消费者模式是一种在LabVIEW编程环境中用于实现并发数据处理的设计模式。它基于生产者和消费者之间的解耦思想，通过队列来实现数据的传递和处理。 在LabVIEW中，生产者是负责生成数据的模块，而消费者...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值