【JAVA】：万字长篇带你了解JAVA并发编程-并发设计模式【五】

已于 2023-11-08 09:27:31 修改
阅读量147 收藏
点赞数
分类专栏： # 并发编程 文章标签： java 设计模式 多线程 并发
于 2023-11-07 19:46:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k316378085/article/details/134244385
版权

目录

个人主页: 【⭐️个人主页】
需要您的【💖 点赞+关注】支持 💯

JAVA并发系列文章

  1. 【JAVA】：万字长篇带你了解JAVA并发编程【一】-CSDN博客
  2. 【JAVA】：万字长篇带你了解JAVA并发编程-线程池【二】-CSDN博客
  3. 【JAVA】：万字长篇带你了解JAVA并发编程-并发集合【三】-CSDN博客
  4. 【JAVA】：万字长篇带你了解JAVA并发编程-线程安全【四】-CSDN博客
  5. 【JAVA】：万字长篇带你了解JAVA并发编程-并发设计模式【五】-CSDN博客
  6. 【JAVA】：万字长篇带你了解JAVA并发编程-死锁优化【六】-CSDN博客

【JAVA】：万字长篇带你了解JAVA并发编程-并发设计模式【五】

Immutability模式【不可变模式】

利用不可变对象解决并发问题的模式，就是不可变模式。

如果对象一旦被创建，状态就不会再发生任何变化，并且只允许存在只读方法，这个对象就是不可变对象。

要实现Immuatability模式很简单，将一个类本身及其所有的属性都设为 final ，并且方法都是只读的，需要注意的是，如果类的属性也是引用类型，那么其对应的类也要满足不可变的特性。

final 应该都很熟悉了，用它来修饰类和方法，分别表示类不可继承、属性不可改变。

Java 中具备不可变性的类型包括：
• String
• final 修饰的基本数据类型
• Integer、Long、Double 等基本数据类型的包装类
• Collections 中的不可变集合

经常用到的String对象和各种基础类型的包装类，比如，Long，Integer都具备不可变性。更进一步，基本数据类型的包装类都用到了享元模式（Flyweight Pattern）, 利用享元模式（Flyweight Pattern）可以减少创建对象的数量，从而减少内存占用。Java 语言里面 Long、Integer、Short、Byte 等这些基本数据类型的包装类都用到了享元模式。

但是在使用不可变模式时，一定要搞清楚特定不可变对象的边界在哪里。

😒: 比如，一个final类C的final成员变量a，当a的内部存在非final的其他对象时，并且C中存在着get_a的public接口，那么C就不是线程安全的。

Copy-on-Write 模式

写时复制（Copy-on-Write, COW或者CoW）是一种延时策略，只要在真正需要复制的时候才复制，而不是提前复制好。同时还支持按需复制，COW通常用于操作系统领域提升性能。
在这里插入图片描述

在操作系统领域，除了创建进程用到了 Copy-on-Write，很多文件系统也同样用到了，例如 Btrfs (B-Tree File System)、aufs（advanced multi-layered unification filesystem）等。相比较而言，Java 提供的 Copy-on-Write 容器，由于在修改的同时会复制整个容器，所以在提升读操作性能的同时，是以内存复制为代价的。除了上面我们说的 Java 领域、操作系统领域，很多其他领域也都能看到 Copy-on-Write 的身影：Docker 容器镜像的设计是 Copy-on-Write，甚至分布式源码管理系统 Git 背后的设计思想都有 Copy-on-Write

Copy-on-Write模式适用于对数据的实时性不敏感，读多写少且对读性能要求极为苛刻的小数据场景。

具体的实现也很简单，当数据需要修改时，先复制一份出来，在复制的数据上进行修改，并发读还是在旧的数据上，当数据修改完成后，再将老数据替换为修改后的新数据即可。但需要注意的是，当发生并发写时，可以使用CAS的策略来完成。

CopyOnWriteArrayList 和CopyOnWriteArraySet这两个 Copy-on-Write 容器在修改的时候会复制整个数组，所以如果容器经常被修改或者这个数组本身就非常大的时候，是不建议使用的。反之，如果是修改非常少、数组数量也不大，并且对读性能要求苛刻的场景，使用 Copy-on-Write 容器效果就非常好了。

🌴 总而言之，Copy-on-Write适合对读的性能要求很高，读多写少，弱一致性场景。如Dubbo中的路由表。

Thread Local Storage 模式

线程本地存储模式（ThreadLocal）

大多数并发问题都是由于变量的共享导致的，多个线程同时读写同一变量便会出现原子性，可见性等问题。局部变量是线程安全的，本质上也是由于各个线程各自拥有自己的变量，避免了变量的共享。
Java 中使用了 ThreadLocal 来实现避免变量共享的方案。ThreadLocal 保证在线程访问变量时，会创建一个这个变量的副本，这样每个线程都有自己的变量值，没有共享，从而避免了线程不安全的问题。

线程封闭的本质就是避免共享，除了局部变量，还有Java提供的线程本地存储（ThreadLocal）也可以实现。

Java中的设计方案：
类Thread拥有threadLocals属性，threadLocals属性的类型是ThreadLocalMap容器，ThreadLocalMap容器中以ThreadLocal为key，维护不同类型的value。ThreadLocalMap 里对 ThreadLocal 的引用是弱引用（WeakReference），所以只要== Thread 对象可以被回收，那么 ThreadLocalMap 就能被回收==。这样不容易产生内存泄露。

线程池中使用

在线程池中使用ThreadLocal很容易产生内存泄漏，原因在于线程池中线程的存活时间过长，往往都是和程序同生共死的。.

这意味着Thread持有的ThreadLocalMap一直都不会被回收，再加上ThreadLocalMap中的Entry对ThreadLocal是弱引用（WeakReference），所以只要ThreadLocal结束了自己的生命周期就可以被回收掉。但Entry中的Value是被Entry强引用的，所以即便Value的生命周期结束了，Value也是无法被回收的，从而导致内存泄漏。

那么在线程池中，我们需要自己手动释放对Value的强引用，可以使用try{}finally{}方案。

通过ThreadLocal创建的线程变量，其子线程是无法继承的，也就是通过ThreadLocal创建了线程变量V，后续该线程创建了子线程，而这个子线程中无法通过访问ThreadLocal来访问父线程的线程变量V。
Java提供了InheritableThreadLocal来支持这种特性，InheritableThreadLocal是ThreadLocal的子类，所以用法和ThreadLocal相同。我完全不建议你在线程池中使用 InheritableThreadLocal，不仅仅是因为它具有 ThreadLocal 相同的缺点——可能导致内存泄露，更重要的原因是：线程池中线程的创建是动态的，很容易导致继承关系错乱，如果你的业务逻辑依赖 InheritableThreadLocal，那么很可能导致业务逻辑计算错误，而这个错误往往比内存泄露更要命。

public class ThreadLocalTest {
    private static final ThreadLocal<SimpleDateFormat> threadLocal =
            ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    public static SimpleDateFormat safeDateFormat() {
        return threadLocal.get();
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<SimpleDateFormat> task1 = new FutureTask<>(ThreadLocalTest::safeDateFormat);
        FutureTask<SimpleDateFormat> task2 = new FutureTask<>(ThreadLocalTest::safeDateFormat);
        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);
        t1.start();
        t2.start();
        System.out.println(task1.get() == task2.get());//返回false，表示两个对象不相等
    }
}

Guarded Suspension模式

Suspension 是“挂起”、“暂停”的意思，而 Guarded 则是“担保”的意思，连在一起 就是确保挂起。
当线程在访问某个对象时，发现条件不满足，就暂时挂起等待条件满足时 再次访问。

保护性暂停设计模式(Guarded Suspension) ,一般适用于 一个线程等待另外一个线程的执行结果,两个线程一一对应,可以划分为同步的设计模式.

Guarded Suspension 设计模式是很多设计模式的基础，比如生产者消费者模式，同样在 Java 并发包中的 BlockingQueue 中也大量使用到了 Guarded Suspension 设计模式。

如果你需要一个结果要源源不断的从一个线程到另外一个线程,那就需要使用生产者消费者模式->即消息队列.

Guarded Suspension 模式本质上是一种等待唤醒机制的实现，只不过 Guarded Suspension 模式将其规范化了。规范化的好处是你无需重头思考如何实现，也无需担心实现程序的可理解性问题，同时也能避免一不小心写出个 Bug 来。但 Guarded Suspension 模式在解决实际问题的时候，往往还是需要扩展的，扩展的方式有很多，本篇文章就直接对 GuardedObject 的功能进行了增强， 当然，你也可以创建新的类来实现对 Guarded Suspension 模式的扩展。Guarded Suspension 模式也常被称作 Guarded Wait 模式、Spin Lock 模式（因为使用了 while 循环去等待）。

Java的API很多都按照保护性暂停这种设计模式来的,比如 join,future.

Guarded Suspension 模式的结构图，非常简单，一个对象 GuardedObject，内部有一个成员变量——受保护的对象，以及两个成员方法——get(Predicate p)和onChanged(T obj)方法。
在这里插入图片描述

 class GuardedObject<T>{
  //受保护的对象
  T obj;
  final Lock lock = new ReentrantLock();
  final Condition done = lock.newCondition();
  final int timeout=1;
  //获取受保护对象  
  T get(Predicate<T> p) {
    lock.lock();
    try {
      //MESA管程推荐写法
      while(p.test(obj)){
        done.await(timeout, TimeUnit.SECONDS);
      }
    }catch(InterruptedException e){
      throw new RuntimeException(e);
    }finally{
      lock.unlock();
    }
    //返回非空的受保护对象
    return obj;
  }
  //事件通知方法
  void onChanged(T obj) {
    lock.lock();
    try {
      this.obj = obj;
      done.signalAll();
    } finally {
      lock.unlock();
    }
  }

  // TEST
      @Test
    public void testGuardedObject(){
        SimpleThreadUtils.newLoopThread(2,"gs",1,(t)->{
            if (t.getNo() % 2 != 0){

                System.out.println("准备获取");
                String s = go.get(Objects::isNull);
                System.out.println("获取OK  " + s );
            }else {
                try {
                    Thread.sleep(2000);
                    go.onChanged("hello world");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        })  ;


        SimpleThreadUtils.wait(1000,()->{});
    }
}

扩展 Guarded Suspension 模式

GuardedObject类中增加如下代码，扩展GuardedSupsensionObject 管理功能

//保存所有GuardedObject
  final static Map<Object, GuardedObject> gos=new ConcurrentHashMap<>();
  //静态方法创建GuardedObject
  static <K> GuardedObject create(K key){
    GuardedObject go=new GuardedObject();
    gos.put(key, go);
    return go;
  }
  static <K, T> void fireEvent(K key, T obj){
    GuardedObject go=gos.remove(key);
    if (go != null){
      go.onChanged(obj);
    }
  }

Balking模式

在Guarded Suspension模式中，如果消息未获得返回，消费者会始终阻塞在等待条件上，但需要快速放弃也是一个常见的需求。比如，自动存盘需求中，如果文件没有改变，就无需磁盘操作。又一个更常见的需求是，单次初始化操作时，使用init变量来控制。

通常会使用一个状态变量status来控制是否存在改变，如果对原子性有要求，可以使用互斥锁，如果对原子性无特殊要求，直接使用volatile`即可。

public class Balking {

    /**
     * 已编辑
     */
    private volatile boolean status = false;
    private String buffer;

    private String file;
    public synchronized void save() {
        System.out.println("开始保存。。。");
        if (!status) {
            System.out.println("取消保存，已经处理了");
            return;
        }
        writeToFile(buffer);
        status = false;
    }

    public synchronized void edit(String changeContent) {
        this.buffer = changeContent;
        status = true;
    }

    /**
     * 模拟写到文件中
     */
    private void writeToFile(String newContent) {
        this.file = newContent;
    }

    public void print(){
        System.out.println("> file : " + this.file);
    }


    public static void main(String[] args) {
        Balking balking = new Balking();

        SimpleThreadUtils.newLoopThread(3,"balk",100,(a)->{
           if (a.getNo() % 3 == 0){

               balking.edit("hello world "  + a.getName() +":"+ Math.floor(Math.random() * 10 ));
           }else {
               balking.save();
               balking.print();
           }
        });

        SimpleThreadUtils.wait(1000,()->{});
    }
}

Thread-Per-Message

所谓Per, 就是 “每~” 的意思, 因此, Thread-Per-Message 模式直译过来就是 “每一个消息一个线程” 的意思, Message 在这里可以理解为 “请求” 或 “命令”, 为每个命令或请求分配一个新的线程, 由这个新线程来执行处理- 这就是 Thread-Per-Message 模式, 在该模式中, 消息的 "委托端" 和 "执行端" 是不同的线程, 消息的委托端线程会告诉执行端的线程 “这项任务交给你执行了”
在这里插入图片描述

在这里插入图片描述

public class ThreadPerMessage {

    public static class Host {
        Helper helper = new Helper();

        public void request(String request) {
            createThreadRun(() -> {
                helper.run(request);
            });
        }

        private void createThreadRun(Runnable o) {
             // 一般我们不直接new Thread，因为线程创建管理再java中很重，容易导致内存泄漏问题
            new Thread(o, UUID.randomUUID().toString()).start();
            // 可以使用线程池技术 juc包中的一些线程池或线程工厂进行线程的创建管理
           // threadFactory.newThread(o).start();
        }
    }
    public static class Helper {
        public void run(String request) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+" : 执行请求 " + request);
        }
    }


    public static void main(String[] args) {
        Host host = new Host();
        for (int i = 0; i < 100; i++) {
            host.request("hello");
        }
        SimpleThreadUtils.wait(1000,()->{});
    }
}

线程创建

  • java.util.concurrent.·ThreadFactory·接口
  • java.util.concurrent.Executors·类获取的ThreadFactory
  • java.util.concurrent.Executor接口
  • java.util.concurrent.ExecutorService接口
  • java.util.concurrent.ScheduledExecutorService接口

Worker Thread模式 (线程池模式)

也叫ThreadPool(线程池模式)
Java语言中，·Thread-Per-Message·毕竟还是一种高消耗的并发模式，如果可以使用阻塞队列做任务池，再创建固定数量的线程消费队列中的任务，这种方式也是SDK并发工具包里提供的线程池方案。

线程池有很多优点，比如，避免重复创建，销毁线程，能够限制创建线程的上限 等等。但需要重点关注并 设置阻塞队列 ，比如，无界的阻塞队列可能在高并发下导致OOM，不建议使用，而有界的阻塞队列需要配合合理的拒绝策略。即，在创建线程池时，建议使用有界队列，并清晰的指明拒绝策略，并且，最好还能为线程赋予一个业务相关的名字，便于调试。
更重要的是，在Worker Thread模式的线程池方案中，需要时刻关注提交到线程池中的任务是否相互独立，如果任务间存在依赖关系，则可能导致线程死锁。死锁产生的原因通常是，线程池中存在相互依赖的任务。比如，线程池中的全部线程都在执行任务1，并且阻塞等待任务2的完成，当提交任务2后，当前并没有任何空闲的线程去调度执行，于是世界静止，死锁产生。

在这里插入图片描述

角色

  • Request 任务制造者
  • Channel 任务工厂
  • Worker 工人
import java.util.Date;

/**
 * @author 孔翔
 * @since 2023-11-07
 * copyright for author : 孔翔 at 2023-11-07
 * java-study
 */
public class WorkerThread {

    /**
     * 请求任务
     */
    public static class RequestTask   {

        private final String taskName;
        private final Date taskDate;

        RequestTask(String taskName, Date taskDate) {
            this.taskDate = taskDate;
            this.taskName = taskName;
        }

        /**
         * Runs this operation.
         */
        public void runTask() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(this.taskName + " : 任务执行完成" + ": by " + Thread.currentThread().getName());
        }
    }

    /**
     * 任务工厂处理
     */
    public static class Channel {

        public final static int MAX_WORKER = 10;
        /**
         * 任务流水线。使用队列
         * 这里直接使用工具类，如果自己编写，可以参考
         *
         * @see GuardedSuspension
         */
        private RequestTask[] requestTasks = new RequestTask[MAX_WORKER];
        /**
         * 线程池，使用可复用，数量可控的线程池降低线程开销
         */
        private  Worker[] workerThreadPool = new Worker[MAX_WORKER];

        private volatile int queueSize ;

        Channel(){
            initWorkPool();
        }

        private void initWorkPool() {
            for (int i = 0; i < MAX_WORKER; i++) {
                workerThreadPool[i] = new Worker(this,"Worker-"+ i);
                workerThreadPool[i].start();
            }
        }

        public synchronized void putRequest(RequestTask requestTask) throws InterruptedException {
            while (queueSize == MAX_WORKER){
                wait();
            }
            System.out.println("-> "+ requestTask.taskName);
            // 通知其他线程，queue可以put数据
            requestTasks[queueSize] = requestTask;
            queueSize++;
            notifyAll();// 通知消费take
        }


        public synchronized RequestTask takeRequest() throws InterruptedException {
            while (queueSize == 0 ){
                wait();
            }
            queueSize--;
            System.out.println("<- "+ requestTasks[queueSize].taskName);
            notifyAll();
            return requestTasks[queueSize];
         }
    }

    /**
     * 主要处理任务
     */
    public static class Worker extends Thread {
        private Channel channel;
        public Worker(Channel channel  ,String string) {
            super(  string);
            this.channel = channel;
        }

        @Override
        public void run() {
            while (true){
                try {
                    // 直接使用了阻塞队列。如果自己实现这里请增加阻塞代码
                    /*
                        lock.lock();
                        RequestTask request task = channel.taskRequest();
                        while(Task = channel.taskRequest() == null){
                            condition.await();
                        }
                         RequestTask requestTask = channel.taskRequest();
                         requestTask.runTask();
                        finally{
                            lock.unlock();
                        }
                     */
                    RequestTask requestTask = channel.takeRequest();
                    requestTask.runTask();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

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

        Channel channel = new Channel();
        for (int i = 0; i < 100; i++) {
            channel.putRequest(new RequestTask("task:"+ i , new Date()));
        }

        SimpleThreadUtils.holdOn();
    }

}

两阶段终止模式

Two-Phase Termination Patter
两阶段终止模式（Two-Phase Termination）是一种用于优雅终止线程或关闭应用程序的设计模式。它包含两个阶段：准备阶段和终止阶段。

在这里插入图片描述

前面所有的内容都是论述，如何启动多线程去执行一个异步任务。那么，如何优雅的终止线程呢？业界也有一套成熟的方案，叫做“两阶段终止”模式。即，将终止过程分成两个阶段，第一阶段由线程T1向线程T2发送终止指令，第二阶段是由线程T2响应终止指令。

在Java语言中，Java线程存在4种状态：初始状态（NEW），可运行/运行状态（RUNNABLE），休眠状态（BLOCKED，WAITING，TIMED_WAITING）和终止状态（TERMINATED）。如果要让一个线程优雅的进入终止状态，一个大前提是让线程首先进入RUNNABLE状态，即，将线程从休眠状态中唤醒至可运行/运行状态，这个可以通过interrupt()方法来实现。

实现上，可以使用一个状态标志位status，在线程T1里设置T2.status后，调用T2.interrupt，将T2从可能的休眠状态中唤醒，T2检查status是否符合终止条件，如果符合，则尝试完成正确的收尾，并优雅退出。

好处：

  • 线程安全：两阶段终止模式可以确保在终止过程中不会发生并发问题，保证线程安全。
  • 可控性：通过两个明确的阶段，可以更好地控制终止过程，确保在终止前完成必要的清理和资源释放操作。
  • 可靠性：两阶段终止模式可以处理异常情况，即使在终止过程中出现异常，也能够正常地完成终止操作。
    缺点：延迟、 复杂性 、需要协作

两阶段终止模式适用于以下场景：

  • 线程终止
  • 应用程序关闭
  • 资源释放
  • 任务取消

总的来说，两阶段终止模式适用于需要优雅地终止线程或关闭应用程序，并确保在终止过程中完成必要的清理和资源释放操作的场景。

/**
 * @author 孔翔
 * @since 2023-11-07
 * copyright for author : 孔翔 at 2023-11-07
 * java-study
 */
public class TwoPhaseTermination {

    // 两阶段终止分为两个阶段
    // 1. 发送终止指令
    //    》
    // 2. 执行终止操作

    public static class TwoPhaseThread implements Runnable {
        private volatile boolean stopFlag;

        // 1. 发送命令
        public void terminal(){
            this.stopFlag = true;
        }

        @Override
        public void run() {
            while (!stopFlag) {
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + "任务线程正在运行...");
                } catch (InterruptedException e) {
                    // 执行命令
                    Thread.currentThread().interrupt();
                    System.out.println(Thread.currentThread().getName() + "任务线程收到终止信号，执行终止操作");
                }
            }
        }
    }


    public static void main(String[] args) {
        TwoPhaseThread twoPhaseThread = new TwoPhaseThread();
        Thread thread = new Thread(twoPhaseThread);
        thread.start();

        // 发送终止线程
        new Thread(()->{
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("发送执行终止线程命令");
            stopThread(thread,twoPhaseThread);

        }).start();

        SimpleThreadUtils.holdOn();
    }

    private static void stopThread(Thread thread, TwoPhaseThread twoPhaseThread) {
        twoPhaseThread.terminal();
        thread.interrupt();
    }

}

生产者-消费者模式

两个线程池通过一个阻塞队列连接起来，一个生产者线程池向队列添加任务，另一个消费者线程池从队列中消费任务，两个线程池并不知道对方的存在，符合架构设计上的“解耦”，支持异步，并可以通过控制两个线程池的线程数目，平衡生产者和消费者的速度差异。

并且，通过分析任务的类型，可以在消费端更精细化的进行控制。比如，如果执行单个任务的消耗与多个任务批量执行的消耗类似，则可以在大并发的场景下，消费端批量处理或者分阶段的批量处理来提高效率。
在这里插入图片描述

这个比较简单

import com.beust.ah.A;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * 生产者-消费者模式
 *
 * @author 孔翔
 * @since 2023-11-07
 * copyright for author : 孔翔 at 2023-11-07
 * java-study
 */
public class ProductConsumer {
    // 核心 ： 阻塞队列连接



    public static class ConsumerRunnable<T> implements Runnable {
        private final BlockingQueue<T> queue;

        ConsumerRunnable(BlockingQueue<T> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    T take = queue.take();
                    handle(take);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        private void handle(T take) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("---> 执行任务" + take.toString());
        }
    }

    public static class  Product<T>  {
        private final BlockingQueue<T> queue;

        Product(BlockingQueue<T> queue) {
            this.queue = queue;
        }

        public void create(T t ){
            try {
                queue.put(t);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }


    public static void main(String[] args) {

        BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
        ConsumerRunnable<String> consumerRunnable = new ConsumerRunnable<>(queue);
        Product<String> product = new Product<>(queue);

        new Thread(consumerRunnable).start();

        new Thread(()->{
            for (int i = 0; i < 1000; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                product.create("i="+ i );
            }
        }).start();

        SimpleThreadUtils.holdOn()；

    }

}

参考学习：

https://www.jianshu.com/p/18a07025e7e0

嘉羽很烦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
algorithms_in_java:用Java编写的教科书算法
06-30
用Java编写的教科书算法 这个存储库中表示的高级算法都是我自己根据互联网上许多算法资源的指导独立实现的。 每个文件都归功于相应的贡献者，详细说明了每个贡献者带来的内容。 要编译这些程序中的任何一个，都需要...
v.Assignments：Java评论
02-25
在Java编程语言中，"评论"是代码中不可或缺的一部分，它们对提高代码可读性和维护性起到了关键作用。本文将深入探讨Java中的不同类型的注释、如何使用它们以及它们在软件开发过程中的重要性。 首先，Java提供了三种...
并发设计模式（一）
pngyul的博客
05-03 613
避免共享的设计模式 随便扯扯，刚开始我学到这里的时候，我有点茅舍顿开的感觉。怎么说呢，比如我现在呆的公司，有一个批量导出订单excel的功能。这个功能前员工已经实现了，当时我在阅读这部分代码的时候就觉得写这个代码的人很吊。他在代码中，利用多线程并发的批量请求数据，多线程封装符合导出格式的数据，而此时，他不是直接就写到excel中，而是先到一个阻塞队列中，然后另外开一个线程从队列中读数据写入到excel中（还有很多细节）。当时我就在想，他是怎么想到这种处理方式。原来这就是一种并发设计模式，就是下面会讲到的生产
并发设计模式
weixin_43837268的博客
02-13 784
1、Immutability模式：如何利用不变性解决并发问题？“多个线程同时读写同一共享变量存在并发问题”，这里的必要条件之一是读写，如果只有读，而没有写，是没有并发问题的。解决并发问题，其实最简单的办法就是让共享变量只有读操作，而没有写操作。这个办法如此重要，以至于被上升到了一种解决并发问题的设计模式：不变性（Immutability）模式。所谓不变性，简单来讲，就是对象一旦被创建之后，状态就不再发生变化。换句话说，就是变量一旦被赋值，就不允许修改了（没有写操作）；没有修改操作，也就是保持了不变性。（1）
并发编程（四）---设计模式
YSecret_Y的博客
09-02 353
同步异步 ， 举个例子来说，一家餐厅吧来了5个客人，同步的意思就是说，来第一个点菜，点了个鱼，好， 厨师去捉鱼杀鱼，过了半小时鱼好了给第一位客人，开始下位一位客人，就这样一个一个来，按顺序来相同， 异步呢，异步的意思就是来第一位客人，点什么，点鱼，给它一个牌子，让他去一边等吧，下一位客人接着点菜，点完接着点让厨师做去吧，哪个的菜先好就先端出来，同步的优点是：同步是按照顺序一个一个来，不会乱掉，更不会出现上面代码没有执行完就执行下面的代码， 缺点：是解析的速度没有异步的快；异步的优点是：异步是接取一个任务，直
常用并发设计模式
xjk201的博客
12-10 998
设计并发场景业务时 考虑先不加锁 考虑下面的几种并发设计模式： 思考：在一个线程 T1 中如何正确安全的终止线程 T2？ 错误思路1：使用线程对象的 stop() 方法停止线程 stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁， 其它线程将永远无法获取锁 。 错误思路2：使用 System.exit(int) 方法停止线程 目的仅是停止一个线程，但这种做法会让整个程序都停止 正确思路：利用Java线程的中断机制 Two-phase Te
多线程和并发编程（6）—并发编程的设计模式
yangnk的技术记录
09-27 181
为每一个处理任务分配一个线程。在 Java 中的线程是一个重量级的对象，创建成本很高，一方面创建线程比较耗时，另一方面线程占用的内存也比较大。Future未来模式是一种异步处理的模式，就是在针对处理事件比较长的任务时，创建一个异步线程来处理任务，返回一个Future的引用，等到后面必须要要结果的时候，可以通过Future的引用来获取异步线程处理的结果。Copy-on-Write模式适合读多写少的场景，他的实现思路是在需要进行写操作时候，会复制一个副本，在副本中进行写的操作，在写完之后再合并到原来的变量中。
java-deal-the-CLOB-data0.zip_大数据 编程_数据处理
09-23
在Java编程中，处理大数据和复杂数据类型是常见的任务，特别是在数据库编程中。本章将聚焦于处理大数据对象，特别是`CLOB`（Character Large Object）数据类型。`CLOB`用于存储大量的文本数据，如长篇文章、XML文档...
JTeaser:JTeaser是一个java程序总结一篇文章
07-17
**JTeaser：Java文章摘要生成器** JTeaser是一个基于Java开发的程序，它的主要功能是自动对文章进行总结，生成文章的摘要。在信息爆炸的时代，快速获取文章核心内容变得至关重要，JTeaser正是为此目的而设计的工具...
多线程并发和设计模式学习笔记(代码)
09-02
多线程并发从,学习笔记,代码+注释,从线程创建开始到多线程并发,相关锁以及一些设计模式等
java高并发程序设计及23种设计模式
10-08
java的高并发程序设计视频教程 及 java 23种设计模式 希望能给大家带来帮助
31.常用并发设计模式精讲
lyw2019的博客
10-06 85
跳出来，看全局；钻进去，看本质。
四种并发编程模型简介
sinolover的专栏
03-02 737
概述 并发往往和并行一起被提及，但是我们应该明确的是“并发”不等同于“并行” • 并发：同一时间 对待 多件事情 （逻辑层面） • 并行：同一时间 做(执行) 多件事情 (物理层面) 并发可以构造出一种问题解决方法，该方法能够被用于并行化，从而让原本只能串行处理的事务并行化，更好地发挥出当前多核CPU，分布式集群的能力。 但是，并...
18个并发场景的设计模式详解，有没有你的盲区
最新发布
威哥爱编程，一个坚持研究技术的80后老鸟，擅长后端、AI 大模型、鸿蒙等技术体系，愿与你在技术路上一起成长！
04-18 628
最后再调强一下，这些模式在多线程并发编程中非常有用。在分布式应用中，并发场景无处不在，理解和掌握这些并发模式的编码技巧，有助于我们在开发中解决很多问题，这要把这些与23种设计模式混淆了，虽然像单例模式是同一个，但这个是考虑并发场景下的应用。拜拜了您誒，晚安。
Java面试题：设计模式在并发编程中的创新应用，Java内存管理与多线程工具类的综合应用，Java并发工具包与并发框架的创新应用
bigorsmallorlarge的专栏
03-20 789
本文通过对三道综合性的Java技术面试题的解析，深入探讨了设计模式在并发编程中的创新应用、Java内存管理与多线程工具类的综合应用，以及Java并发工具包与并发框架的实际应用。作为Java技术专家，深入理解设计模式、内存管理、多线程工具类、并发工具包和并发框架的综合应用是关键。在本文中，我将为您解析三道综合性的Java技术面试题，这些题目将融合设计模式、内存管理、多线程工具类、并发工具包和并发框架等知识点，并包含独特的创新点。通过创新应用这些工具和框架，可以解决复杂的并发问题，提高应用的性能和可靠性。
【杂记】高并发的几种设计模式
搬砖.......
05-28 1094
单例模式是一种常见的设计模式，一般用于安全对象管理，比如XML读写实例、系统配置实例、任务调度实例、数据库连接池实例等。单例模式一般分为懒汉式、饿汉式。饿汉式单例在类加载时候，就直接初始化。懒汉式，就是在类使用的时候，才对单例进行初始化。
并发的设计模式(一)
二狗家有矿
02-19 204
1.写在前面 笔者介绍并发的工具类，以及基础的东西，今天笔者打算来介绍一下并发中的设计模式。 2.不变性模式 2.1概述 不变性模式，所谓不变性，简单来讲，就是对象一旦被创建之后，状态就不再发生变化。换句话说，就是变量一旦被赋值，就不允许修改了（没有写操作）；没有修改操作，也就是保持了不变性。 2.2快速实现具备不可变性的类 就是将一个类所有的属性都设置成final的，并且只允许存在只读的方法，那么这个类基本上就具备不可变性了。更严格的做法是这个类本身也是final的，也就是不允许继承。 ja
Java编程：深入理解Clob类与Class对象
在Java编程中，`Clob`类是一个非常重要的部分，特别是在处理大量文本数据时。`CLOB`（Character Large Object）是数据库中用于存储大文本数据的数据类型，如长篇文章、文档或HTML代码。在Java中，`Clob`接口提供了与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

嘉羽很烦

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

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

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

打赏作者

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

抵扣说明：

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

余额充值