java并发设计模式

最新推荐文章于 2024-04-28 09:44:26 发布
最新推荐文章于 2024-04-28 09:44:26 发布
阅读量289 收藏 1
点赞数
分类专栏： # 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44504809/article/details/117934495
版权

文章目录

终止模式

两阶段终止模式（Two Phase Termination）

错误思路

1、使用线程对象的 stop() 方法停止线程
stop方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁， 其它线程将永远无法获取锁
2、使用 System.exit(int) 方法停止线程
目的仅是停止一个线程，但这种做法会让整个程序都停止

两阶段终止模式–interrupt

在这里插入图片描述

@Slf4j(topic = "c.tpt")
public class TwoPhaseTermination {

    private Thread monitor;

    public void start(){
        monitor = new Thread("t1"){
            @Override
            public void run() {
                while (true){
                    if(Thread.currentThread().isInterrupted()){
                        log.debug("处理后事");
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                        log.debug("检测记录");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                }

            }
        };
        monitor.start();
    }

    public void stop(){
        monitor.interrupt();
    }

}

两阶段终止模式—volatile

class TwoPhaseTermination {
    // 监控线程
    private Thread monitorThread;
    // 停止标记
    private volatile boolean stop = false;

    // 启动监控线程
    public void start() {
        monitorThread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                // 是否被打断
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                }
            }
        }, "monitor");
        monitorThread.start();
    }

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

同步模式

保护性暂停

保护性暂停即 Guarded Suspension，用在一个线程等待另一个线程的执行结果

要点

1、有一个结果需要从一个线程传递到另一个线程，让他们关联同一个GuardedObject
2、如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
3、JDK 中，join 的实现、Future的实现，采用的就是此模式
4、使用wait—notifyall

在这里插入图片描述

public class GuardedObject {
    private Object response;
    private final Object obj = new Object();

    public Object get(){
        synchronized (obj){
            while (response == null){
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        return response;
    }
    public void setResponse(Object response){
        synchronized (obj){
            this.response = response;
            obj.notifyAll();
        }
    }
}

带超时版 GuardedObject

    public static void main(String[] args) {
        GuardedObject object = new GuardedObject();
        new Thread(){
            @Override
            public void run() {
                object.get(1000);
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(1020);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                object.setResponse(10000);
            }
        }.start();

    }

    private Object response;
    private final Object obj = new Object();
     mill 表示要等待多久 2000
    public Object get(long mill){

        synchronized (obj){
            //记录最初时间 15:00:00
            long begin = System.currentTimeMillis();
            //已经经历的时间
            long timePassed = 0;
            while (response == null){
           		 // 这一轮循环应该等待的时间
                long waitTime = mill - timePassed;
                log.info("waitTime:{}",waitTime);
                // 经历的时间超过了最大等待时间时，退出循环
                if(waitTime <= 0){
                    log.info("break");
                    break;
                }
                try {
                    obj.wait(waitTime); // 虚假唤醒 15:00:01
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 求得经历时间
                timePassed = System.currentTimeMillis() - begin;
                log.info("timePassed:{},response:{}",timePassed,response);
            }
        }
        return response;
    }

    public void setResponse(Object response){
        synchronized (obj){
            this.response = response;
            log.info("notify...");
            obj.notifyAll();
        }
    }
}

多任务版 GuardedObject

结果产生者和结果消费者是一一对应的关系。

在这里插入图片描述

新增id用来标识Guarded Object

public class GuardedObject {

    //标识Guarded Object
    private int id;

    public int getId() {
        return id;
    }

    public GuardedObject(int id) {
        this.id = id;
    }
    
    private Object response;
    public Object get(long mill){
        synchronized (this){
            //记录最初时间
            long begin = System.currentTimeMillis();
            //已经经历的时间
            long timePassed = 0;
            while (response == null){
                long waitTime = mill - timePassed;
                if(waitTime <= 0){
                    break;
                }
                try {
                    this.wait(waitTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                timePassed = System.currentTimeMillis() - begin;
            }
        }
        return response;
    }

    public void setResponse(Object response){
        synchronized (this){
            this.response = response;
            this.notifyAll();
        }
    }
}

中间解耦类

ublic class MailBoxes {

    private static Map<Integer,GuardedObject> boxes = new ConcurrentHashMap<>();

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

    //送信人获取邮箱--GuardedObject
    public static GuardedObject getGuarderObject(int id){
        //根据唯一id获取邮箱并删除
        return boxes.remove(id);
    }

    //收信人创建邮箱--GuardedObject
    public static GuardedObject createGuarderObject(){
        GuardedObject go = new GuardedObject(generateId());
        boxes.put(go.getId(), go);
        return go;
    }

    //获取所有id
    public static Set<Integer> getIds(){
        return boxes.keySet();
    }
}

业务代码

@Slf4j
public 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.getGuarderObject(id);
        log.info("送信id：{},内容：{}",id,mail);
        guardedObject.setResponse(mail);
    }
}

@Slf4j
class People extends Thread{
    @Override
    public void run() {
        GuardedObject go = MailBoxes.createGuarderObject();
        log.info("开始收信 id：{}",go.getId());
        Object mail = go.get(5000);
        log.info("收到的信 id：{}, mail:{}" ,go.getId(),mail);
    }
}

犹豫模式（blaking）

Balking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回
保证线程只启动一次，实现线程的单例

在这里插入图片描述

顺序控制

固定运行顺序（wait-notify版）

@Slf4j(topic = "c.Test25")
public class Test25 {
    static final Object lock = new Object();
    // 表示 t2 是否运行过
    static boolean t2runned = false;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                while (!t2runned) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("1");
            }
        }, "t1");


        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                log.debug("2");
                t2runned = true;
                lock.notify();
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

固定运行顺序（park-unpark版）

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

        Thread t1 = new Thread(() -> {
            LockSupport.park();
            log.debug("1");
        }, "t1");
        t1.start();

        new Thread(() -> {
            log.debug("2");
            LockSupport.unpark(t1);
        },"t2").start();
    }
}

交替输出（wait-notify版）

public class Test27 {
    public static void main(String[] args) {
        WaitNotify wn = new WaitNotify(1, 5);
        new Thread(() -> {
            wn.print("a", 1, 2);
        }).start();
        new Thread(() -> {
            wn.print("b", 2, 3);
        }).start();
        new Thread(() -> {
            wn.print("c", 3, 1);
        }).start();
    }
}

/*
输出内容       等待标记     下一个标记
   a           1             2
   b           2             3
   c           3             1
 */
class WaitNotify {
    // 打印               a           1             2
    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.print(str);
                flag = nextFlag;
                this.notifyAll();
            }
        }
    }

    // 等待标记
    private int flag; // 2
    // 循环次数
    private int loopNumber;

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

交替输出（await-singnal版）

public class Test30 {
    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();
        new Thread(() -> {
            awaitSignal.print("a", a, b);
        }).start();
        new Thread(() -> {
            awaitSignal.print("b", b, c);
        }).start();
        new Thread(() -> {
            awaitSignal.print("c", c, a);
        }).start();

        Thread.sleep(1000);
        awaitSignal.lock();
        try {
            System.out.println("开始...");
            a.signal();
        } finally {
            awaitSignal.unlock();
        }

    }
}

class AwaitSignal extends ReentrantLock{
    private int loopNumber;

    public AwaitSignal(int loopNumber) {
        this.loopNumber = loopNumber;
    }
    //            参数1 打印内容， 参数2 进入哪一间休息室, 参数3 下一间休息室
    public void print(String str, Condition current, Condition next) {
        for (int i = 0; i < loopNumber; i++) {
            lock();
            try {
                current.await();
                System.out.print(str);
                next.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                unlock();
            }
        }
    }
}

交替输出（park-unpark版）

public class Test31 {

    static Thread t1;
    static Thread t2;
    static Thread t3;
    public static void main(String[] args) {
        ParkUnpark pu = new ParkUnpark(5);
        t1 = new Thread(() -> {
            pu.print("a", t2);
        });
        t2 = new Thread(() -> {
            pu.print("b", t3);
        });
        t3 = new Thread(() -> {
            pu.print("c", t1);
        });
        t1.start();
        t2.start();
        t3.start();

        LockSupport.unpark(t1);
    }
}

class ParkUnpark {
    public void print(String str, Thread next) {
        for (int i = 0; i < loopNumber; i++) {
            LockSupport.park();
            System.out.print(str);
            LockSupport.unpark(next);
        }
    }

    private int loopNumber;

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

异步模式

生产者消费者模式

在这里插入图片描述

1、与前面的保护性暂停中的 GuardObject 不同，不需要产生结果和消费结果的线程一一对应
2、消费队列可以用来平衡生产和消费的线程资源
3、生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
4、消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
5、JDK 中各种阻塞队列，采用的就是这种模式

消息实体类

public class Message {
    private int id;
    private Object message;

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

    public int getId() {
        return id;
    }

    public Object getMessage() {
        return message;
    }

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

消息队列

//消息队列，java线程之间通信
public class MessageQueue {
    //消息队列集合
    private LinkedList<Message> list = new LinkedList<>();
    //队列容量
    private int capcity;

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

    //获取消息
    public Message take(){
        //检查队列是否为空
        synchronized (list){
            while (list.isEmpty()){
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Message message = list.removeFirst();
            list.notify();
            return message;
        }
    }

    //存入消息
    public void put(Message message){
        synchronized (list){
            //检查队列是否已满
            while (list.size() == capcity){
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.add(message);
            list.notify();
        }

    }

}

工作线程

让有限的工作线程（Worker Thread）来轮流异步处理无限多的任务。也可以将其归类为分工模式，它的典型实现就是线程池，也体现了经典设计模式中的享元模式。
注意，不同任务类型应该使用不同的线程池，这样能够避免饥饿，并能提升效率。

饥饿

固定大小线程池会有饥饿现象。这是由于线程池的数量不足以及分工不明确导致导致的。
比如，t1和t2是线程池中的2个线程，他们都需要处理2个任务A，B任务，这是2个阶段任务，只有A执行完毕，B任务才能开始执行。
如果t1执行A，t2接着执行B,这是没有问题的。
但是如果同时来了2个用户，t1执行了第一个用户的A任务，t2执行了第2个用户的A任务，这就会造成B任务没有人执行，也就是所谓的饥饿现象。

解决方法：

不同任务类型应该使用不同的线程池，这样能够避免饥饿，并能提升效率

享元模式

Flyweight pattern.享元模式
一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象
使用场景： 当需要重用数量有限的同一类对象时

体现

1、在JDK中 Boolean，Byte，Short，Integer，Long，Character 等包装类提供了 valueOf 方法，例如Long 的valueOf 会缓存 -128~127 之间的 Long 对象，在这个范围之间会重用对象，大于这个范围，才会新建 Long对象。
2、String串池
3、BigDecimal BigInteger

在这里插入图片描述

在这里插入图片描述

halulu.me
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java高频面试题-设计模式
q66562636的博客
06-07 3863
1 你所知道的设计模式有哪些？Java 中一般认为有 23 种设计模式，我们不需要所有的都会，但是其中常用的几种设计模式应该去掌握。下面列出了所有的设计模式。需要掌握的设计模式我单独列出来了，当然能掌握的越多越好。总体来说设计模式分为三大类：创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘
java常见的几种设计模式
snmkc_csdn的博客
06-21 8704
java常见的几种设计模式
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
Java的23种设计模式
初心不忘、始终方得
09-01 5490
大话java23种设计模式，通俗易懂
Java高并发8种解决方案，真的很全，亲测有效，嘿嘿嘿
PythonAigc的博客
04-28 6268
Java高并发解决方案涉及多个层面，包括设计模式、并发工具类、框架、缓存、数据库优化等。以下是一些常见的Java高并发解决方案及其解决思路、方法和代码示例： 1. 使用线程池 解决思路： 通过线程池来管理线程，避免频繁创建和销毁线程，从而提高系统性能。 解决方法： 使用java.util.concurrent.ExecutorService和java.util.concurrent.Executors来创建线程池。
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
Java 设计模式——单例模式
代码星辰的博客
07-08 4248
本文介绍了单例模式的相关知识。
java并发总结
liujiqing123的博客
10-11 1万+
一、并发基础 ㅤ 1、进程与线程 ㅤ 进程 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等） 线程 一个进程之内可以分为一到多个
Java设计模式学习总结
Java技术江湖
07-08 5654
设计模式 创建型模式 创建型模式 创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。 单例 单例模式保证全局的单例类只有一个实例，这样的话使用的时候直接获取即可，比如数据库的一个连接，Spring里的be...
Java 并发编程
m0_61470267的博客
06-05 9204
java线程的回顾，java多线程出现的问题及解决方案，引入线程池的的原因，线程池的参数设置，以及引入ThreadLocal 线程变量，理解ThreadLocal的底层实现原理。
java pipeline并发模式
tjy451592402的博客
03-06 8847
1、pipeline简介 pipeline又称为管道，是一种在计算机普遍使用的技术。举个最普遍的例子，如下图所示cpu流水线，一个流水线分为4部分，每个部分可以独立工作，于是可以处理多个数据流。linux 管道也是一个常用的管道技术，其字符处理功能十分强大，在面试过程中常会被问到。在分布式处理领域，由于管道模式是数据驱动，而目前流行的Spark分布式处理平台也是数据驱动的，两者非常合拍，于是在s...
Java常用并发设计模式精讲
03-17
Java并发设计模式是Java开发中不可或缺的一部分，它们用于解决多线程环境下的各种问题，以提高程序的效率、稳定性和可维护性。本教程将深入探讨六个关键的并发设计模式，帮助开发者更好地理解和应用这些模式。 1. *...
实战Java高并发程序设计模式
06-18
3. **并发设计模式**：设计模式是解决特定问题的成熟方案。在并发编程中，常见的模式有生产者消费者模式、读写锁模式、单例模式（考虑线程安全的双重检查锁定）等。这些模式可以帮助开发者避免并发问题，提升代码的...
Java并发编程设计原则和模式
03-07
本资料“Java并发编程设计原则和模式”深入探讨了如何在Java环境中有效地进行并发处理，以充分利用系统资源并避免潜在的并发问题。 一、并发编程基础 并发是指两个或多个操作在同一时间段内执行，但并不意味着这些...
并发设计模式
04-15
### 并发设计模式 #### 一、设计模式概述 设计模式是在软件开发过程中，针对常见问题提出的一系列经过验证的解决方案。它们帮助开发者更好地理解并解决特定的问题，并且能够提高代码的可读性、可维护性和可扩展性...
Java核心技术,并发设计模式，数据结构与算法
10-04
Java核心技术,并发设计模式，数据结构与算法，SpringBoot,OAuth2.0源码分析，Mysql进阶篇,Git高级操作，Netty教程，Redis设计与实战,Flink入门教程，Kafka入门与架构分析,Linux入门与Shell编程,DDD架构设计
守望先锋资讯小程序(源码).zip
07-28
守望先锋资讯小程序(源码).zip
无人智能化关键技术及其在火炮系统中的应用_常建龙.caj
最新发布
07-28
无人智能化关键技术及其在火炮系统中的应用_常建龙
本科设计-机器学习识别图片验证码-可执行内含文档代码-可执行内含文档代码.zip
07-28
本科设计-机器学习识别图片验证码-可执行内含文档代码-可执行内含文档代码.zip
Java并发设计模式解析与实战
"并发设计模式，Java相关教学资料，由实战Java高并发程序设计讲师葛一鸣提供，内容涵盖设计模式、并发控制等主题。" 在软件开发中，特别是在Java这样的多线程环境中，理解并应用并发设计模式是至关重要的。这些模式...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

halulu.me

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值