其他多线程设计模式

最新推荐文章于 2023-04-15 11:56:59 发布
最新推荐文章于 2023-04-15 11:56:59 发布
阅读量234 收藏
点赞数
分类专栏： 多线程设计模式学习记录篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43719015/article/details/105717457
版权

观察者设计模式观察线程的生命周期

//使用观察者设计模式观察线程的生命周期   被观察者是Thread
public abstract class ObservableRunnable implements Runnable {

    final protected LifeCycleListener listener; //观察者

    public ObservableRunnable(final LifeCycleListener listener) {
        this.listener = listener;
    }

    protected void notifyChange(final RunnableEvent event) {
        listener.onEvent(event);
    }

    public enum RunnableState {
        RUNNING, ERROR, DONE
    }

    public static class RunnableEvent {
        private final RunnableState state;
        private final Thread thread;//哪个线程
        private final Throwable cause;//失败的原因

        public RunnableEvent(RunnableState state, Thread thread, Throwable cause) {
            this.state = state;
            this.thread = thread;
            this.cause = cause;
        }

        public RunnableState getState() {
            return state;
        }

        public Thread getThread() {
            return thread;
        }

        public Throwable getCause() {
            return cause;
        }
    }
}

public interface LifeCycleListener {//观察者
    void onEvent(ObservableRunnable.RunnableEvent event);
}

public class ThreadLifeCycleObserver implements LifeCycleListener {

    private final Object LOCK = new Object();//共享数据的问题

    public void concurrentQuery(List<String> ids) {
        if (ids == null || ids.isEmpty())
            return;
             //把自己作为observer给你
        ids.stream().forEach(id -> new Thread(new ObservableRunnable(this) {
            @Override
            public void run() {
                try {
                    notifyChange(new RunnableEvent
                    (RunnableState.RUNNING, Thread.currentThread(), null));
                    System.out.println("query for the id " + id);
                    Thread.sleep(1000L);
//                    int i = 1/0;
                    notifyChange
                    (new RunnableEvent(RunnableState.DONE, Thread.currentThread(), null));
                } catch (Exception e) {
                    notifyChange
                    (new RunnableEvent(RunnableState.ERROR, Thread.currentThread(), e));
                }
            }
        }, id).start());
    }
    @Override
    public void onEvent(ObservableRunnable.RunnableEvent event) {
        //把当前对象传给ObservableRunnable，可能有多线程访问问题
        synchronized (LOCK) {//数据不一致，线程安全问题
            System.out.println("The runnable [" + event.getThread().getName() + "] 
            data changed and state is [" + event.getState() + "]");
            if (event.getCause() != null) {
                //如果失败 了可能再去尝试等操作
                System.out.println("The runnable [" + event.getThread().getName() + 
                "] process failed.");
                event.getCause().printStackTrace();
            }
        }
    }
}

public class ThreadLifeCycleClient {
    public static void main(String[] args) {
        //启动2个线程去干活
        new ThreadLifeCycleObserver().concurrentQuery(Arrays.asList("1", "2"));
    }
}

单线程执行设计模式，有一个门，始终只能一个人通过

public class Client {
    public static void main(String[] args) {
        Gate gate = new Gate();
        User bj = new User("Baobao", "Beijing", gate);
        User sh = new User("ShangLao", "ShangHai", gate);
        User gz = new User("GuangLao", "GuangZhou", gate);

        bj.start();
        sh.start();
        gz.start();
    }
}

/**
 * SharedResource共享资源
 */
public class Gate {//记录一个大门(临界值)的用户信息，这里没有对门进行加锁的方式实现的
    private int counter = 0;
    private String name = "Nobody";
    private String address = "Nowhere";

    /**
     * 临界值
     *
     * @param name
     * @param address
     */
    public synchronized void pass(String name, String address) {
        this.counter++;
        /*race*/
        this.name = name;
        this.address = address;
        verify();
    }

    private void verify() {
        //每次只有一个人通过
        if (this.name.charAt(0) != this.address.charAt(0)) {
            System.out.println("*******BROKEN********" + toString());
        }
    }

    public synchronized String toString() {
        return "No." + counter + ":" + name + "," + address;
    }
}

public class User extends Thread {//有一个门，始终有一个人通过的场景

    private final String myName;

    private final String myAddress;

    private final Gate gate;

    public User(String myName, String myAddress, Gate gate) {
        this.myName = myName;
        this.myAddress = myAddress;
        this.gate = gate;
    }

    @Override
    public void run() {
        System.out.println(myName + " BEGIN");
        while (true) {
            this.gate.pass(myName, myAddress);
        }
    }
}

多线程读写锁分离设计模式

/**
 * ReadWriteLock design pattern
 * Reader-Writer design pattern
 */
public class ReadWritLockClient {
    public static void main(String[] args) {
        final SharedData sharedData = new SharedData(10);
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        new ReaderWorker(sharedData).start();
        new WriterWorker(sharedData, "qwertyuiopasdfg").start();
        new WriterWorker(sharedData, "QWERTYUIOPASDFG").start();
    }
}

public  class SharedData {

    private final char[] buffer;

    private final  ReadWriteLock lock = new ReadWriteLock();

    public SharedData(int  size) {
        this.buffer = new char[size];
        for (int i = 0; i < size; i++) {
            this.buffer[i] = '*';
        }
    }

    public char[] read() throws InterruptedException {
        try {
            lock.readLock();
            return this.doRead();
        } finally {
            lock.readUnlock();
        }
    }

    public void write(char c) throws InterruptedException {
        try {
            lock.writeLock();
            this.doWrite(c);
        } finally {
            lock.writeUnlock();
        }
    }

    private void doWrite(char c) {
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = c;
            slowly(10);
        }
    }

    private char[] doRead() {
        char[] newBuf = new char[buffer.length];
        for (int i = 0; i < buffer.length; i++)
            newBuf[i] = buffer[i];

        slowly(50);
        return newBuf;
    }

    private void slowly(int ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
        }
    }
}

public class ReadWriteLock {
    private int readingReaders = 0;
    private int waitingReaders = 0;
    private int writingWriters = 0;
    private int waitingWriters = 0;
    //实现写锁优先
    private boolean preferWriter = true;

    public ReadWriteLock() {
        this(true);
    }

    public ReadWriteLock(boolean preferWriter) {
        this.preferWriter = preferWriter;
    }

    //获取对象的锁，这里用了try finally   同时用锁的时候也是要try finally的
    public synchronized void readLock() throws InterruptedException {
        this.waitingReaders++;
        try {
            while (writingWriters > 0 || (preferWriter && waitingWriters > 0)) {
                this.wait();
            }
            this.readingReaders++;
        } finally {
            this.waitingReaders--;
        }

    }

    public synchronized void readUnlock() {
        this.readingReaders--;
        this.notifyAll();
    }

    public synchronized void writeLock() throws InterruptedException {
        this.waitingWriters++;
        try {
            while (readingReaders > 0 || writingWriters > 0) {
                this.wait();
            }
            this.writingWriters++;
        } finally {
            this.waitingWriters--;
        }
    }

    public synchronized void writeUnlock() {
        this.writingWriters--;
        this.notifyAll();
    }
}

public class ReaderWorker extends Thread {

    private final SharedData data;

    public ReaderWorker(SharedData data) {
        this.data = data;
    }

    @Override
    public void run() {
        try {
            while (true) {
                char[] readBuf = data.read();
                System.out.println(Thread.currentThread().getName() + " reads " + String.valueOf(readBuf));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class WriterWorker extends Thread {

    private static final Random random = new Random(System.currentTimeMillis());

    private final SharedData data;

    private final String filler;

    private int index = 0;

    public WriterWorker(SharedData data, String filler) {
        this.data = data;
        this.filler = filler;
    }

    @Override
    public void run() {
        try {
            while (true) {
                char c = nextChar();
                data.write(c);
                Thread.sleep(random.nextInt(1000));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private char nextChar() {
        char c = filler.charAt(index);
        index++;
        if (index >= filler.length())
            index = 0;
        return c;
    }
}

多线程 Future 设计模式

public interface FutureTask<T> {

    T call();
}

/**   想想UML类图
 * Future        ->  代表的是未来的一个凭据
 * FutureTask    ->  将你的调用逻辑进行了隔离
 * FutureService ->  桥接 Future和 FutureTask
 */
public class SyncInvoker {

    public static void main(String[] args) throws InterruptedException {
        /*String result = get();//同步调用
        System.out.println(result);*/

        //思路：返回的Future，具体类AsynFuture，任务FutureTask，将他们桥接起来的FutureService  画出uml图分析一下
        FutureService futureService = new FutureService();
        Future<String> future = futureService.submit(() -> {
            try {
                Thread.sleep(10000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "FINISH";
        }, System.out::println);

        //这里没阻塞
        System.out.println("===========");
        System.out.println(" do other thing.");
        Thread.sleep(1000);
        System.out.println("===========");

//        //这里阻塞了
//        String result = future.get();
//        System.out.println(result);
    }

    private static String get()
            throws InterruptedException {
        Thread.sleep(10000l);
        return "FINISH";
    }
}

public class FutureService {//将Future和FutureTask桥接起来

    public <T> Future<T> submit(final FutureTask<T> task) {
        //异步的Future实现 ，调用asynFuture的方法可能是不一样的线程
        AsynFuture<T> asynFuture = new AsynFuture<>();
        new Thread(() -> {
            T result = task.call();
            asynFuture.done(result);
        }).start();
        return asynFuture;
    }

    //执行完后就Consumer
    public <T> Future<T> submit(final FutureTask<T> task, final Consumer<T> consumer) {
        AsynFuture<T> asynFuture = new AsynFuture<>();
        new Thread(() -> {
            T result = task.call();
            asynFuture.done(result);
            //执行后就立马通知了，减少时间误差
            consumer.accept(result);
        }).start();
        return asynFuture;
    }
}

public interface Future<T> {

    T get() throws InterruptedException;
}

public class AsynFuture<T> implements Future<T> {

    private volatile boolean done = false;

    private T result;

    public void done(T result) {
        synchronized (this) {
            this.result = result;
            this.done = true;
            this.notifyAll();//done和get不一定是同一个线程
        }
    }

    @Override
    public T get() throws InterruptedException {
        synchronized (this) {
            while (!done) {
                //阻塞的,考虑多线程
                this.wait();
            }
        }
        return result;
    }
}

多线程Count Down设计模式

public class CustomCountDownClient {

    private static final Random random = new Random(System.currentTimeMillis());

    public static void main(String[] args) throws InterruptedException {

        final CountDown latch = new CountDown(5);
        System.out.println("准备多线程处理任务.");
        //The first phase.

        IntStream.rangeClosed(1, 5).forEach(i ->
                new Thread(() -> {
                    System.out.println(Thread.currentThread().getName() + " is working.");
                    try {
                        Thread.sleep(random.nextInt(1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    latch.down();
                }, String.valueOf(i)).start()
        );

        latch.await();
        //The second phase.
        System.out.println("多线程任务全部结束,准备第二阶段任务");
        System.out.println("............");
        System.out.println("FINISH");
    }
}

public class CountDown {
    private final int total;

    private int counter = 0;

    public CountDown(int total) {
        this.total = total;
    }

    public void down() {
        synchronized (this) {
            this.counter++;
            this.notifyAll();
        }
    }

    public void await() throws InterruptedException {
        synchronized (this) {
            while (counter != total) {
                this.wait();
            }
        }
    }
}

public class JDKCountDown {

    private static final Random random = new Random(System.currentTimeMillis());

    public static void main(String[] args) throws InterruptedException {

        //底层是AbstractQueuedSynchronizer实现的
        final CountDownLatch latch = new CountDownLatch(5);
        System.out.println("准备多线程处理任务.");
        //The first phase.

        IntStream.rangeClosed(1, 5).forEach(i ->
                new Thread(() -> {
                    System.out.println(Thread.currentThread().getName() + " is working.");
                    try {
                        Thread.sleep(random.nextInt(1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    latch.countDown();
                }, String.valueOf(i)).start()
        );

        latch.await();
        //The second phase.
        System.out.println("多线程任务全部结束,准备第二阶段任务");
        System.out.println("............");
        System.out.println("FINISH");

    }
}

在这里插入图片描述

多线程Active Objects设计模式

…

奋斗小亮
关注
专栏目录
多线程设计模式
LVAmber的博客
06-05 1194
什么事设计模式    在软件工程中，设计模式（design pattern）是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。单例模式    单例对象的类必须保证只有一个实例的存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如全局信息配置。    但是何时产生实例，不好判断。    这个实例在getInstance第一次被方位的时候创建实例。   ...
c语言怎样实现多线程,如何用C语言实现多线程
weixin_33917663的博客
05-22 157
该楼层疑似违规已被系统折叠隐藏此楼查看此楼Windows操作系统，C语言实现多线程：#include#includeDWORDAPIENTRYThreadOne(LPVOIDthreadArg){printf("线程开始啦，参数是：%s\n",(char*)threadArg);return0;}intmain(void){HANDLEhThread;...
多线程设计模式之——Producer-Consumer Pattern
laopolu的专栏
12-13 222
此模式是在生产者与消费者之间加入一个“桥梁参与者”来缓冲线程之间的处理速度差。一般可以存在多个生产者与消费者，但当双方都只有一个的时候，又称为Pipe Pattern。 例子：假设有2个生产者,2个消费者，仓库里只能放4个产品。(这里的产品就是String类型的名字而已) [code="java"]//Storage.java public class Storage { p...
【C语言】线程原理及实现
zhoupuxian的博客
05-19 4113
文章目录前言一、原理图二、线程1.线程标识2.线程创建3.修改线程属性4.线程与进程4.线程分离5.线程退出总结 前言 提示：这里可以添加本文要记录的大概内容： 什么是线程？我们首先要知道的一件事情是一个进程里面可以包括多个线程，不能反过来，我们之前了解到的不同进程可以做不一样的事情，我们举一个简单易懂的例子：我们的电脑上面有很多的应用程序，微信、QQ，酷狗音乐等等，我们运行一个应用程序就有一个进程，那什么是线程呢？比如其中一个，我们打开了酷狗音乐，打开音乐听着，这时候你觉得歌好听你就去看评论，这时候你想
C语言实现多线程
最新发布
墨城烟柳ベ旧人殇的博客
04-15 6146
本文主要是学习C语言实现多线程的笔记。
多线程设计模式——Pipeline(流水线)模式
01-27
Pipeline(流水线)模式有时一些线程的步奏比较冗长，而且由于每个阶段的结果与下阶段的执行有关系，又不能分开。可以将任务的处理分解为若干个处理阶段，上一个阶段任务的结果交给下一个阶段来处理，这样每个线程的...
java多线程设计模式_java_设计模式_多线程_多线程课题_
09-29
Java多线程设计模式是Java开发中的核心概念，它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。设计模式是解决特定问题的成熟方案，它们是编程经验的结晶，可以帮助开发者在面临多线程挑战时快速找到...
java多线程设计模式详解(PDF及源码)
07-14
书中包含Java线程的介绍导读、12个重要的线程设计模式和全书总结以及丰富的附录内容。第一章相关线程设计模式的介绍，都举一反三使读者学习更有效。最后附上练习问题，让读者可以温故而知新，能快速地吸收书中的...
Java多线程设计模式_清晰完整PDF版 Java多线程设计模式源代码
11-16
Java多线程设计模式是Java开发中的重要领域，它涉及到如何在并发环境下高效、安全地管理资源和控制程序执行流程。本资料集包含了清晰完整的PDF版书籍和源代码，为学习和理解Java多线程设计模式提供了丰富的素材。 ...
java多线程设计模式源码
01-17
Java多线程设计模式是构建高并发、高性能应用的关键技术之一。这些模式通过优化资源利用、提高程序可读性和可维护性，使并发编程更加高效和安全。以下将详细讲解标题和描述中涉及的一些核心知识点： 1. **线程池...
多线程多进程之其他
aiyu6684的博客
10-16 70
concurrent.futures 模块 #1 介绍 concurrent.futures模块提供了高度封装的异步调用接口 ThreadPoolExecutor：线程池，提供异步调用 ProcessPoolExecutor: 进程池，提供异步调用 Both implement the same interface, which is defined by the abstra...
多线程设计模式集合
两米以下皆凡人的博客
02-13 2108
文章目录1、保护性暂停模式1.1、概述1.2、单任务版GuardedObject1.3、多任务版GuardedObject2、生产者消费者模式2.1、概述2.2、代码实现3、终止模式之两阶段终止4、同步模式之犹豫Balking5、双重检查加锁单例模式6、异步模式之工作线程6.1、定义6.2、饥饿6.3、创建多少线程池合适6.3.1、CPU 密集型运算6.3.2、I/O 密集型运算 1、保护性暂停模式 1.1、概述 旨在用一个线程等待另一个线程的执行结果，因为要等待另一方的结果，因此归类到同步模式 有
c语言多线程单例模式
clize_U的博客
06-22 858
c语言多线程单例模式懒汉模式：#include <pthread.h> #include <stdio.h>pthread_once_t once = PTHREAD_ONCE_INIT;class Singleton { protected: static Singleton *_instance; static void mutex_init(void); //initializ
多线程的设计模式
weixin_30493321的博客
04-24 63
　　并行设计模式属于设计优化的一部分，它是对一些常用的多线程结构的总结和抽象。与串行程序相比，并行结构的程序通常更为复杂。因此合理的使用并行模式在多线程开发中更具有意义，在这里主要介绍future、master-woeker和生产者-消费者模型。 　　future模式有点类似于商品订单。比如在网购时，当看中某件商品时，就可以提交订单，当订单处理完成后，在家里等待商品送货上门即可。或者说...
多线程编程的设计模式 临界区模式(一)
诗剑书生的专栏
08-28 3684
多线程编程的设计模式 临界区模式(一)临界区模式 Critical Section Pattern 是指在一个共享范围中只让一个线程执行的模式.它是所有其它多线程设计模式的基础,所以我首先来介绍它.把着眼点放在范围上,这个模式叫临界区模式,如果把作眼点放在执行的线程上,这个模式就叫单线程执行模式.首先我们来玩一个钻山洞的游戏,我 Axman,朋友 Sager,同事 Pentium4.三个人在八角游
Future 模式
u010919133的专栏
01-28 194
java多线程设计模式全部源码： java多线程设计模式源码 类图 时序图 Main.java public class Main { public static void main(String[] args) { Host host = new Host(); //data1、data2、data3都是FutureDat
单例模式
身在边城 心在编程
06-15 418
单例模式，懒汉模式，饿汉模式
C语言多线程同步 -- 信号量semaphore.h
热门推荐
OOC_ZC的博客
02-24 2万+
多线程读文件使用fopen，出现BUG，然后寻找同步方法，找到这个“信号量“。 首先需要用sem_init(); 初始化sem_t型变量，并设置初始信号量。比如设置为1. 每次调用sem_wait(sem_t *); 信号量减一，当调用sem_post(sem_t *); 信号量加一。 当信号量为0时，sem_wait(); 函数阻塞，等待信号量 >0 时，才进行。 #
Java多线程设计模式解析
除了基本的线程创建，Java还提供了其他多线程设计模式，如Callable和Future，它们可以返回计算结果并支持异常处理。另外，Executor框架（ThreadPoolExecutor、Executors等）提供了更高级的线程管理，能够更好地控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值