多线程设计模式

最新推荐文章于 2024-07-19 15:53:52 发布
最新推荐文章于 2024-07-19 15:53:52 发布
阅读量381 收藏 1
点赞数 1
分类专栏： 多线程 文章标签： 设计模式 java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48468380/article/details/127433597
版权

两阶段终止

线程T1需要终止线程T2时，如果使用stop方法直接终止线程T2，T2申请的锁得不到释放；因此使用两阶段终止模式更加优雅

监控线程

在这里插入图片描述

@Slf4j
public class TwoPhaseTermination{
    private Thread monitor;
	private volatile boolean stop = false;
	// 判断是否执行过start方法
	private boolean starting = false;

    public void start(){
    	synchronized(this){
    		if(starting){
   				return;
   			}
   			starting = true;
    	}
        monitor = new Thread(()->{
            while(true){
                Thread current = Thread.currentThread();
                if(stop){
                    log.debug("料理后事");
                    break;
                }
                try{
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        monitor.start();
    }

    /**
     * 停止监控线程
     */
    public void stop(){
    	stop = true;
        monitor.interrupt();
    }

}

保护性暂停

保护性暂停用在一个线程等待另一个线程的执行结果时
要点：

  • 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个GuardedObject
  • 如果有结果不断从一个线程到另一个线程，那么可以使用消息队列
  • JDK中，join的实现、Future的实现采用的就是这个模式
  • 因为要等待另一方的结果，所以归类到同步模式
    在这里插入图片描述
class GuardedObject{
    private Object response;

    /**
     * 获取结果
     * @return
     */
    public Object getResponse(long timeout) {
        synchronized (this){
            long begin = System.currentTimeMillis();
            long passedTime = 0;
            while(response==null){
                if(passedTime>=timeout){
                    break;
                }
                try{
                    this.wait(timeout-passedTime);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                passedTime = System.currentTimeMillis()-begin;
            }
            return response;
        }
    }

    /**
     * 设置结果
     * @param response
     */
    public void complete(Object response){
        synchronized (this){
            this.response = response;
            this.notifyAll();
        }
    }
}

join原理

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");
        }
		// 超时时间等于0，则一直等待
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
        	// 超时时间大于0
            while (isAlive()) {
            	// 剩余的可以等待的时间
                long delay = millis - now;
                // 如果剩余的可以用的时间小于等于0，表示没法再等待了，直接退出
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

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

  • 与保护性暂停中的GuardObject不同，不需要产生结果和消费结果的线程一一对应
  • 消费队列可以用来平衡生产和消费的线程资源
  • 生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
  • 消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
  • JDK中各种阻塞队列，采用的就是这种模式
    在这里插入图片描述
/***
 * 线程间通信队列
 */
class MessageQueue{
    private LinkedList<Message> queue = new LinkedList<>();
    private int capacity;

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

    public void put(Message message){
        synchronized (queue){
            while(queue.size()==capacity){
                try {
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 从尾部加入消息
            queue.addLast(message);
            queue.notifyAll();
        }

    }

    public Message take(){
        synchronized (queue){
            while(queue.isEmpty()){
                try {
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 从头部取得消息
            Message message = queue.removeFirst();
            queue.notifyAll();
            return message;
        }

    }
}

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;
    }
}

同步模式之顺序控制

固定运行顺序

必须现有两个线程，一个打印1，一个打印2；先要求先打印2再打印1
wait-notify

@Slf4j
public final class Demo{
    private static boolean hasPrintTwo = false;
    private static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread printOne = new Thread(()->{
            synchronized (lock){
                while(!hasPrintTwo){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("{}",1);
            }

        },"t1");

        Thread printTwo = new Thread(()->{
            log.debug("{}",2);
            hasPrintTwo = true;
            synchronized (lock){
                lock.notifyAll();
            }

        },"t2");

        printOne.start();
        Thread.sleep(1000);
        printTwo.start();
    }
}

park/unpark

@Slf4j
public final class Demo{
    private static boolean hasPrintTwo = false;
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread printOne = new Thread(()->{
            while(!hasPrintTwo){
                LockSupport.park();
            }
            log.debug("{}",1);

        },"t1");

        Thread printTwo = new Thread(()->{
            log.debug("{}",2);
            hasPrintTwo = true;
            LockSupport.unpark(printOne);

        },"t2");

        printOne.start();
        Thread.sleep(1000);
        printTwo.start();
    }
}

交替输出

三个线程交替输出a，b，c
wait/notify

@Slf4j
public final class Demo{
    public static void main(String[] args) throws InterruptedException {
        WaitNotify waitNotify = new WaitNotify(1,5);
        Thread printA = new Thread(()->{
            waitNotify.print("A",1,2);
        },"t1");

        Thread printB = new Thread(()->{
            waitNotify.print("B",2,3);
        },"t2");

        Thread printC = new Thread(()->{
            waitNotify.print("C",3,1);
        },"t3");

        printA.start();
        printB.start();
        printC.start();
    }
}

class WaitNotify{
    /**
     * 等待标记,当等待标记和传入的标记一致才会退出等待
     */
    private int flag;
    /**
     * 循环次数
     */
    private int loopNumber;

    public WaitNotify(int flag,int loopNumber){
        this.flag = flag;
        this.loopNumber = loopNumber;
    }

    /**
     * 循环打印
     * @param str
     * @param waitFlag
     * @param nextFlag
     */
    public void print(String str,int waitFlag,int nextFlag){
        for (int i = 0; i < loopNumber; i++) {
            synchronized (this){
                while(flag != waitFlag){
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(str);
                flag = nextFlag;
                this.notifyAll();
            }
        }
    }
}

await/signal

@Slf4j
public final class Demo{
    public static void main(String[] args) throws InterruptedException {
        AwaitSignal awaitSignal = new AwaitSignal(5);
        Condition a = awaitSignal.newCondition();
        Condition b = awaitSignal.newCondition();
        Condition c = awaitSignal.newCondition();
        Thread printA = new Thread(()->{
            awaitSignal.print("A",a,b);
        },"t1");

        Thread printB = new Thread(()->{
            awaitSignal.print("B",b,c);
        },"t2");

        Thread printC = new Thread(()->{
            awaitSignal.print("C",c,a);
        },"t3");

        printA.start();
        printB.start();
        printC.start();

        // 唤醒第一个线程，接下来的线程会被循环睡眠并唤醒
        Thread.sleep(1000);
        awaitSignal.lock();
        try{
            a.signal();
        }finally {
            awaitSignal.unlock();
        }
    }
}

class AwaitSignal extends ReentrantLock{
    private int loopNumber;


    public AwaitSignal(int loopNumber){
        this.loopNumber = loopNumber;
    }

    public void print(String str,Condition current,Condition next){
        for (int i = 0; i < loopNumber; i++) {
            lock();
            try {
                // 将当前条件进入等待
                current.await();
                // 退出当前条件的等待
                System.out.println(str);
                // 唤醒下一条件
                next.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                unlock();
            }
        }
    }
}

park/unpark

@Slf4j
public final class Demo{
    static Thread printA;
    static Thread printB;
    static Thread printC;
    public static void main(String[] args) throws InterruptedException {
        ParkUnPark parkUnPark = new ParkUnPark(5);
        printA = new Thread(()->{
            parkUnPark.print("A",printB);
        },"t1");

        printB = new Thread(()->{
            parkUnPark.print("B",printC);
        },"t2");

        printC = new Thread(()->{
            parkUnPark.print("C",printA);
        },"t3");

        printA.start();
        printB.start();
        printC.start();

        // 唤醒第一个线程，接下来的线程会被循环睡眠并唤醒
        Thread.sleep(1000);
        LockSupport.unpark(printA);
    }
}

class ParkUnPark{
    private int loopNumber;


    public ParkUnPark(int loopNumber){
        this.loopNumber = loopNumber;
    }

    public void print(String str,Thread next){
        for (int i = 0; i < loopNumber; i++) {
            LockSupport.park();
            System.out.println(str);
            LockSupport.unpark(next);
        }
    }
}
老蛙@
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程设计模式综述
Guilai1990的博客
06-05 183
由于多核CPU已经成了每台电脑的标配，计算机性能大大提高，随之带来的是程序员对多核的高效利用，也就是多并发编程。显然，多并发编程大大提高了系统的吞吐率，使得高并发不再遥不可及。但与此同时，也带来了很多令人头疼的问题。为了解决多线程编程带来的问题（如线程安全问题、死锁问题、内存溢出等），通过一些多线程设计模式可以巧妙的避开或者解决这些问题。我们可以在大量的分布式中间件（比如RocketMQ）...
多线程设计模式-主仆模式
Guilai1990的博客
06-08 855
定义：将一个任务（原始任务）分解为若干个语义等同的子任务，并由专门的工作者线程来并行执行子任务 主从模式UML图 Master: 负责原始任务的分解、子任务的派发和子任务处理结果的合并 service: Master参与者对外暴露的接口，用于接收原始任务，并返回其处理结果 splitWork: 将原始任务分解成若干个语义等同的子任务 callSlaves: 将各个子任...
java多线程设计模式
huzhiqiangCSDN的博客
12-23 2635
附件为 java多线程设计模式
java多线程设计模式 -- 流水线模式（Pipeline）
热门推荐
huzhiqiangCSDN的博客
02-24 1万+
十一、流水线模式（Pipeline） 1、核心思想 将一个任务处理分解为若干个处理阶段，其中每个处理阶段的输出作为下一个处理阶段的输入，并且各个处理阶段都有相应的工作者线程去执行相应的计算。 2、评价： 充分利用CPU，提高其计算效率。 允许子任务间存在依赖关系的条件下实现并行计算。 非常便于采用单线程模型实现对子任务的处理。 有错误处理 Pip
java多线程设计模式源码
01-17
Java多线程设计模式是构建高并发、高性能应用的关键技术之一。这些模式通过优化资源利用、提高程序可读性和可维护性，使并发编程更加高效和安全。以下将详细讲解标题和描述中涉及的一些核心知识点： 1. **线程池...
多线程设计模式1
08-08
在多线程编程中，设计模式是解决并发问题的有效手段，可以提高代码的可读性...在实际开发中，根据具体需求，还可以采用其他的多线程设计模式，例如生产者-消费者模式、线程池、读写锁等，以适应各种复杂的并发场景。
多线程设计模式——Pipeline(流水线)模式
01-27
Pipeline(流水线)模式有时一些线程的步奏比较冗长，而且由于每个阶段的结果与下阶段的执行有关系，又不能分开。可以将任务的处理分解为若干个处理阶段，上一个阶段任务的结果交给下一个阶段来处理，这样每个线程的...
(一)js前端开发中设计模式前篇之对象
峰会路转的博客
07-17 227
改进版与基础版要分开测试，不然会互相影响到。
模板方法原理与C++实现
Black.Spider的博客
07-15 296
定义一个操作中的算法骨架（稳定的），而将一些步骤的实现延迟到子类中（变化的）。模板方法使得子类可以复用一个算法的结构，而只改变（重写）这个算法的特定步骤。模板方法是一种非常实用且常见的设计模式，它使用简单的机制（虚函数）为应用程序框架提供了灵活的扩展点。模板方法中被模板方法调用的虚函数可以有具体实现，也可以没有任何实现（纯虚函数），但一般访问权限为protected，因为作为算法的一部分，它没有对外单独开放的必要。
java设计模式：02-创建型设计模式-概览
Mr_Air_Boy的博客
07-17 331
创建型模式（Creational Patterns）主要用于处理对象创建的机制，旨在以适当的方式创建对象。这些模式的目的是将对象的创建过程与系统的其他部分分离，以提高系统的灵活性和可扩展性。通过使用创建型模式，可以使系统在创建对象时更加灵活，减少耦合，提高代码的可维护性。
Java 和 SpringBoot 中的设计模式 详解
最新发布
weixin_68074170的博客
07-19 285
假如有一结果api结果返回值的类Person，其在代码中频繁被使用。这两种使用方法的弊端有：（1）：当只需要部分参数的时候需要再定义个构造函数（比如失败的情况只需要code和message，结果肯定是空，因此不需要data），且一旦参数较多，则；（2）；Lombok插件的@Builder注解。
跟着GPT学设计模式之模板模式
欢迎关注公众号“雨林寻北”，添加个人微信codetrend（备注技术）。
07-19 568
模板模式是一种行为型设计模式，它定义了一个操作中的算法骨架，将一些步骤的具体实现延迟到子类中。该模式使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
Linux C++ 056-设计模式之迭代器模式
Tianwx的博客
07-15 445
本节关键字：Linux、C++、设计模式、迭代器模式 相关库函数：
设计模式之策略模式
qq_58076226的博客
07-19 280
将类中经常改变或者可能改变的部分提取作为一个抽象策略接口类，然后在类中包含这个对象的实例，这样类实例在运行时就可以随意调用实现了这个接口的类的行为比如定以一系列的算法，把每一个算法封装起来，并且使可以相互替换，使得算法可独立于使用它的客户而变化，这就是策略模式1、环境类(Context):通过ConcreteStrategy具体策略来配置，持有Strategt对象并维护对Strategy对象的引用。可定义一个接口来让Strategy访问它的数据。
设计模式--外观模式
weixin_46520767的博客
07-18 527
外观模式（Facade Pattern）是一种结构型设计模式，它为子系统中的一组接口提供了一个一致的界面。外观模式定义了一个高层接口，使得子系统更加容易使用。它主要用于简化复杂系统的接口，提供一个简洁的接口给客户端使用，而隐藏系统的复杂性。
设计模式9-工厂模式（Factory Method）
qq_41810539的博客
07-16 971
通过对象超级模式绕开。动态内存分配（new)，来避免对象创建过程中所导致的紧耦合(依赖具体类)，从而支持对象创建的稳定，它是结构抽象之后的第一步工作。工厂方法（Factory Method Pattern）抽象工厂（Abstract Factory Pattern）提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体的类。原型模式（Prototype Pattern）将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值