JUC——day03 &&JUC辅助类&&读写锁&&阻塞队列&&线程池&&Fork/Join

最新推荐文章于 2023-06-26 15:43:26 发布
最新推荐文章于 2023-06-26 15:43:26 发布
阅读量181 收藏
点赞数
分类专栏： # JUC 文章标签： java juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45483328/article/details/123236571
版权

文章目录

1. JUC辅助类

JUC提供了丰富的JUC辅助类，通过这些辅助类可以很好的解决线程数量过 多时 Lock 锁的频繁操作

1.1 CountDownLatch

解决问题：CountDownLatch 类可以设置一个计数器，然后通过 countDown 方法来进行减1的操作，使用 await 方法等待计数器不大于0，然后继续执行 await 方法之后的语句。

  • CountDownLatch 主要有两个方法，当一个或多个线程调用 await 方法时，这些线程会阻塞
  • 其它线程调用 countDown 方法会将计数器减 1(调用 countDown 方法的线程不会阻塞)
  • 当计数器的值变为 0 时，因 await 方法阻塞的线程会被唤醒，继续执行
//6个同学陆续离开教室之后，班长才能锁门
public static void main(String[] args) throws InterruptedException {
    CountDownLatch countDownLatch = new CountDownLatch(6); //设置计数

    for (int i = 1; i <= 6; i++) {
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "离开");
            countDownLatch.countDown();//减1
        }, String.valueOf(i)).start();
    }

    countDownLatch.await(); //减为0后执行
    System.out.println("班长锁门");
}

1.2 CyclicBarrier

CyclicBarrier 看英文单词可以看出大概就是循环阻塞的意思，在使用中CyclicBarrier 的构造方法第一个参数是目标障碍数，每次执行 CyclicBarrier 一次障碍数会加一，如果达到了目标障碍数，才会执行 cyclicBarrier.await()之后的语句。可以将 CyclicBarrier 理解为加1操作

//召唤神龙
private static final int NUMBER = 7;

public static void main(String[] args) {
    CyclicBarrier cyclicBarrier = new CyclicBarrier(CyclicBarrierDemo.NUMBER, ()->{
        System.out.println("召唤神龙");//阻塞数达到7，执行runnable的run()
    });

    for (int i = 1; i <= 7; i++) {
        new Thread(()->{
            try {
                System.out.println("收集到" + Thread.currentThread().getName() + "号龙珠");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        },String.valueOf(i)).start();
    }
}

1.3 Semaphore

Semaphore 的构造方法中传入的第一个参数是最大信号量（可以看成最大线程池），每个信号量初始化为一个最多只能分发一个许可证。使用 acquire 方法获得许可证，release 方法释放许可

//抢车位, 6部汽车 3个停车位
public static void main(String[] args) {
    Semaphore semaphore = new Semaphore(3);

    for (int i = 1; i <= 6; i++) {
        new Thread(()->{
            try {
                semaphore.acquire(); //请求资源
                System.out.println(Thread.currentThread().getName() + "获取到车位");
                TimeUnit.SECONDS.sleep(new Random(5).nextInt());
                System.out.println(Thread.currentThread().getName() + "释放车位");
                semaphore.release(); //释放资源
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, String.valueOf(i)).start();
    }
}

2. 读写锁

对于一个临界资源，在没有加锁的情况下，随意访问这个临界资源，可能会导致异常错误。于是我们通过引入ReentrantLock和synchronized对资源进行加锁保护，但是这两个锁都是独占锁，同一时间只能有一个线程进行访问，遇到读写操作，读可以同时读，写只能一个线程写，这就引出了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁

读写锁比互斥锁允许对于共享数据更大程度的并发。每次只能有一个写线程，但是同时可以有多个线程并发地读数据。ReadWriteLock适用于读多写少的并发情况。

2.1 ReentrantReadWriteLock分析

  • 获取顺序

    • 非公平模式（默认）

      当以非公平初始化时，读锁和写锁的获取的顺序是不确定的。非公平锁主张竞争获取，可能会延缓一个或多个读或写线程，但是会比公平锁有更高的吞吐量。

    • 公平模式

      当以公平模式初始化时，线程将会以队列的顺序获取锁。当当前线程释放锁后，等待时间最长的写锁线程就会被分配写锁；或者有一组读线程组等待时间比写线程长，那么这组读线程组将会被分配读锁。
      当有写线程持有写锁或者有等待的写线程时，一个尝试获取公平的读锁（非重入）的线程就会阻塞。这个线程直到等待时间最长的写锁获得锁后并释放掉锁后才能获取到读锁。

  • 可重入

    允许读锁可写锁可重入。写锁可以获取读锁，读锁不能获得写锁。

  • 锁降级

    允许写锁降低为读锁（先获取写锁，再获取读锁，再释放写锁，最后释放读锁）

  • 中断锁的获取

    在读锁和写锁的获取过程中支持中断

  • 支持Condition

    写锁提供Condition实现

  • 监控

    提供确定锁是否被持有等辅助方法

//演示读写锁降级
public class Demo1 {

    public static void main(String[] args) {
        //可重入读写锁对象
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();//读锁
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();//写锁

        //锁降级
        //1 获取写锁
        writeLock.lock();
        System.out.println("manongyanjiuseng");
        
        //2 获取读锁
        readLock.lock();
        System.out.println("---read");
        
        //3 释放写锁
        writeLock.unlock();

        //4 释放读锁
        readLock.unlock();
    }
}

2.2 模拟多线程在map中取数据和读数据（使用读写锁）

class MyCache {
    private volatile Map<String, Object> map = new HashMap<>();
    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock(); //读锁
    private final ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock(); //写锁

    public void put(String key, Object value) {
        writeLock.lock(); //写锁加锁

        try {
            System.out.println(Thread.currentThread().getName() + "开始写入");
            TimeUnit.MICROSECONDS.sleep(300);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "写完了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock(); //写锁解锁
        }
    }

    public Object get(String key) {
        readLock.lock(); //读锁加锁
        Object result = null;
        try {
            System.out.println(Thread.currentThread().getName() + "读取数据");
            TimeUnit.MICROSECONDS.sleep(300);
            result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读完了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock(); //读锁解锁
        }

        return result;
    }
}

public class ReadWriteDemo1 {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for (int i = 1; i <= 5; i++) {
            final int num = i;
            new Thread(()->{
                myCache.put(num + "", num + "");
            }, String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            final int num = i;
            new Thread(()->{
                Object o = myCache.get(num + "");
                System.out.println(Thread.currentThread().getName() + "结果为" + o);
            }, String.valueOf(i)).start();
        }
    }
}

在这里插入图片描述

可以看出：写的时候是独占，读的时候是共享

3. 阻塞队列

阻塞队列，顾名思义，他首先是一个队列，数据先进先出，类似于我们日常生活中的排队。

多线程环境中，通过队列可以很容易实现数据共享，比如经典的“生产者”和“消费者”模型中，通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程，另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的情况呢？理想情况下，如果生产者产出数据的速度大于消费者消费的速度，并且当生产出来的数据累积到一定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。然而，在concurrent包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。好在此时，强大的concurrent包横空出世了，而他也给我们带来了强大的BlockingQueue。（在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒）

这也是我们在多线程环境下，为什么需要BlockingQueue的原因。作为BlockingQueue的使用者，我们再也不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue都给你一手包办了。既然BlockingQueue如此神通广大，让我们一起来见识下它的常用方法：

3.1 BlockingQueue的核心方法

  1. 放入数据

    • offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.（本方法不阻塞当前执行方法 的线程）

    • offer(E o, long timeout, TimeUnit unit)：可以设定等待的时间，如果在指定的时间内，还不能往队列中加入BlockingQueue，则返回失败。

    • put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

  2. 获取数据

  • poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null;
  • poll(long timeout, TimeUnit unit)：从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据。否则知道时间超时还没有数据可取，返回失败。
  • take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入;
  • drainTo():一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数），通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁。

3.2 常见BlockingQueue

3.2.1 ArrayBlockingQueue（常用）

基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长数组，以便缓存队列中的数据对象，这是一个常用的阻塞队列，除了一个定长数组外，ArrayBlockingQueue内部还保存着两个整形变量，分别标识着队列的头部和尾部在数组中的位置。

ArrayBlockingQueue在生产者放入数据和消费者获取数据，都是共用同一个锁对象，由此也意味着两者无法真正并行运行，这点尤其不同于LinkedBlockingQueue；按照实现原理来分析，ArrayBlockingQueue完全可以采用分离锁，从而实现生产者和消费者操作的完全并行运行。Doug Lea之所以没这样去做，也许是因为ArrayBlockingQueue的数据写入和获取操作已经足够轻巧，以至于引入独立的锁机制，除了给代码带来额外的复杂性外，其在性能上完全占不到任何便宜。 ArrayBlockingQueue和LinkedBlockingQueue间还有一个明显的不同之处在于，前者在插入或删除元素时不会产生或销毁任何额外的对象实例，而后者则会生成一个额外的Node对象。这在长时间内需要高效并发地处理大批量数据的系统中，其对于GC的影响还是存在一定的区别。而在创建ArrayBlockingQueue时，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁。

3.2.2 LinkedBlockingQueue(常用)

基于链表的阻塞队列，同ArrayListBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（LinkedBlockingQueue可以通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程会被唤醒，反之对于消费者这端的处理也基于同样的原理。而LinkedBlockingQueue之所以能够高效的处理并发数据，还因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

作为开发者，我们需要注意的是，如果构造一个LinkedBlockingQueue对象，而没有指定其容量大小，LinkedBlockingQueue会默认一个类似无限大小的容量（Integer.MAX_VALUE），这样的话，如果生产者的速度一旦大于消费者的速度，也许还没有等到队列满阻塞产生，系统内存就有可能已被消耗殆尽了。

3.2.3 DelayQueue

DelayQueue中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue是一个没有大小限制的队列，因此往队列中插入数据的操作（生产者）永远不会被阻塞，而只有获取数据的操作（消费者）才会被阻塞。

使用场景：DelayQueue使用场景较少，但都相当巧妙，常见的例子比如使用一个DelayQueue来管理一个超时未响应的连接队列。

3.2.4 PriorityBlockingQueue

基于优先级的阻塞队列（优先级的判断通过构造函数传入的Compator对象来决定），但需要注意的是PriorityBlockingQueue并不会阻塞数据生产者，而只会在没有可消费的数据时，阻塞数据的消费者。因此使用的时候要特别注意，生产者生产数据的速度绝对不能快于消费者消费数据的速度，否则时间一长，会最终耗尽所有的可用堆内存空间。在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁。

3.2.5 SynchronousQueue

一种无缓冲的等待队列，类似于无中介的直接交易，有点像原始社会中的生产者和消费者，生产者拿着产品去集市销售给产品的最终消费者，而消费者必须亲自去集市找到所要商品的直接生产者，如果一方没有找到合适的目标，那么对不起，大家都在集市等待。相对于有缓冲的BlockingQueue来说，少了一个中间经销商的环节（缓冲区），如果有经销商，生产者直接把产品批发给经销商，而无需在意经销商最终会将这些产品卖给那些消费者，由于经销商可以库存一部分商品，因此相对于直接交易模式，总体来说采用中间经销商的模式会吞吐量高一些（可以批量买卖）；但另一方面，又因为经销商的引入，使得产品从生产者到消费者中间增加了额外的交易环节，单个产品的及时响应性能可能会降低。

声明一个SynchronousQueue有两种不同的方式，它们之间有着不太一样的行为。公平模式和非公平模式的区别:

如果采用公平模式：SynchronousQueue会采用公平锁，并配合一个FIFO队列来阻塞多余的生产者和消费者，从而体系整体的公平策略；

但如果是非公平模式（SynchronousQueue默认）：SynchronousQueue采用非公平锁，同时配合一个LIFO队列来管理多余的生产者和消费者，而后一种模式，如果生产者和消费者的处理速度有差距，则很容易出现饥渴的情况，即可能有某些生产者或者是消费者的数据永远都得不到处理。

总结: 不存储元素的阻塞队列，也即单个元素的队列.

3.2.6 LinkedTransferQueue

LinkedTransferQueue 是一个由链表结构组成的无界阻塞 TransferQueue 队 列。相对于其他阻塞队列，LinkedTransferQueue 多了 tryTransfer 和transfer 方法。

LinkedTransferQueue 采用一种预占模式。意思就是消费者线程取元素时，如果队列不为空，则直接取走数据，若队列为空，那就生成一个节点（节点元素为 null）入队，然后消费者线程被等待在这个节点上，后面生产者线程入队时发现有一个元素为 null 的节点，生产者线程就不入队了，直接就将元素填充到该节点，并唤醒该节点等待的线程，被唤醒的消费者线程取走元素，从调用的方法返回。

4. 线程池

线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

4.1 特点

  • 降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
  • 提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。
  • 提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

在这里插入图片描述

4.2 线程池种类

  • Executors.newFixedThreadPool(int)一池N线程

    ExecutorService threadPool1 = Executors.newFixedThreadPool(5); //5个窗口

  • Executors.newSingleThreadExecutor()一池一线程

    ExecutorService threadPool2 = Executors.newSingleThreadExecutor(); //一个窗口

  • Executors.newCachedThreadPool()一池可扩容根据需求创建线程

    ExecutorService threadPool3 = Executors.newCachedThreadPool();

//演示线程池三种常用分类
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //一池五线程
        ExecutorService threadPool1 = Executors.newFixedThreadPool(5); //5个窗口

        //一池一线程
        ExecutorService threadPool2 = Executors.newSingleThreadExecutor(); //一个窗口

        //一池可扩容线程
        ExecutorService threadPool3 = Executors.newCachedThreadPool();
        //10个顾客请求
        try {
            for (int i = 1; i <=10; i++) {
                //执行
                threadPool3.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" 办理业务");
                });
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭
            threadPool3.shutdown();
        }
    }
}

4.3 线程池的七个参数

上面每一个类型的线程池，实际上都调用了此方法

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

这里介绍这个七个参数的意思：

  • int corePoolSize 核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
  • int maximumPoolSize 线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
  • long keepAliveTime, TimeUnit unit,线程存活时间.表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
  • BlockingQueue<Runnable> workQueue,阻塞队列（排队的线程放入）
  • ThreadFactory threadFactory,线程工厂，用于创建线程
  • RejectedExecutionHandler handler 拒绝测试（线程满了）
    • ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
    • ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
    • ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
    • ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

4.4 具体工作流程

  • 在执行创建对象时不会创建线程
  • 创建线程的时候execute()才会创建
  • 先到常驻线程，满了之后再到阻塞队列进行等待，阻塞队列满了之后，在往外扩容线程，扩容线程不能大于最大线程数。大于最大线程数和阻塞队列之和后，会执行拒绝策略。

在这里插入图片描述

4.5 自定义线程池

实际在开发中不允许使用Executors创建，而是通过ThreadPoolExecutor的方式，规避资源耗尽风险

项目中创建多线程时，使用常见的三种线程池创建方式，单一、可变、定长都 有一定问题，原因是 FixedThreadPool 和 SingleThreadExecutor 底层都是用 LinkedBlockingQueue 实现的，这个队列最大长度为 Integer.MAX_VALUE， 容易导致 OOM。所以实际生产一般自己通过 ThreadPoolExecutor的7个参数，自定义线程池

//自定义线程池创建
public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
            2,
            5,
            2L,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(3),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()
        );

        //10个顾客请求
        try {
            for (int i = 1; i <=10; i++) {
                //执行
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" 办理业务");
                });
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭
            threadPool.shutdown();
        }
    }
}

5.Fork/Join

5.1 Fork/Join框架简介

Fork/Join 它可以将一个大的任务拆分成多个子任务进行并行处理，最后将子任务结果合并成最后的计算结果，并进行输出。Fork/Join 框架要完成两件事情：

Fork：把一个复杂任务进行分拆，大事化小

Join：把分拆任务的结果进行合并

在 Java 的 Fork/Join 框架中，使用两个类完成上述操作

  • ForkJoinTask:我们要使用 Fork/Join 框架，首先需要创建一个 ForkJoin 任务。 该类提供了在任务中执行 fork 和 join 的机制。通常情况下我们不需要直接集成ForkJoinTask 类，只需要继承它的子类，Fork/Join 框架提供了两个子类：
    • RecursiveAction：用于没有返回结果的任务
    • RecursiveTask:用于有返回结果的任务
  • ForkJoinPool:ForkJoinTask 需要通过 ForkJoinPool 来执行

5.2 实例

具体案例：1加到100，相加两个数值不能大于10

package com.shang.forkJoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class ForkJoinDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建MyTask对象
        MyTask myTask = new MyTask(0,100);
        //创建分支合并池对象
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Integer> forkJoinTask = forkJoinPool.submit(myTask);
        //获取最终合并之后结果
        Integer result = forkJoinTask.get();
        System.out.println(result);
        //关闭池对象
        forkJoinPool.shutdown();
    }
}

class MyTask extends RecursiveTask<Integer> {

    //拆分差值不能超过10，计算10以内运算
    private static final Integer VALUE = 10;
    private int begin ;//拆分开始值
    private int end;//拆分结束值
    private int result ; //返回结果

    //创建有参数构造
    public MyTask(int begin,int end) {
        this.begin = begin;
        this.end = end;
    }

    //拆分和合并过程
    @Override
    protected Integer compute() {
        //判断相加两个数值是否大于10
        if((end-begin)<=VALUE) {
            //相加操作
            for (int i = begin; i <=end; i++) {
                result = result+i;
            }
        } else {//进一步拆分
            //获取中间值
            int middle = (begin+end)/2;
            //拆分左边
            MyTask task01 = new MyTask(begin,middle);
            //拆分右边
            MyTask task02 = new MyTask(middle+1,end);
            //调用方法拆分
            task01.fork();
            task02.fork();
            //合并结果
            result = task01.join()+task02.join();
        }
        return result;
    }
}
有什么奇怪！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JAVA】多线程案例之阻塞队列---》生产者消费者模型
qq_61862008的博客
10-11 661
加上阻塞队列的场景就比如包饺子：你爸爸负责擀饺子皮，你和你妈妈负责包饺子（爸爸是生产者，你跟妈妈是消费者），如果你爸爸的速度很快，你跟妈妈才包好10个饺子，爸爸就已经擀好了100张饺子皮，此时你爸爸可以停下来玩会手机休息~反过来，你跟你妈妈包饺子的速度大于爸爸擀饺子皮的速度的话，你跟你妈妈可以停下来等爸爸擀多些饺子皮，你们娘俩再开始包饺子。，等到这个满的队列中有元素出队列了，这时你上一步插入元素的动作就会接着往下执行~反过来也一样，假如队列的元素空了，你准备从这个空队列里取元素，3.实现队列的阻塞功能。
Java多线程案例——阻塞队列（生产者消费者模型）
小小码农
01-11 928
阻塞队列（生产者消费者模型）
阻塞式队列——生产者消费者模型
m0_51529857的博客
08-12 253
文章目录前言一、阻塞队列下面来康康代码如何实现的吧传统的生产者、消费者问题总结 前言 生产者，消费者模型无论是平常开发中，还是面试中都是很经常用到的，它是通过一个容器来解决生产者和消费者的强耦合问题，生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不同等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里获取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力，这个阻塞队列就是用来给生产者和消费者解耦的 一、阻塞队列 阻塞队列就如同.
BlockingQueue简单了解
chijingduxie7771的博客
10-18 174
前言 在Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 认...
阻塞队列——生产者消费者模型
weixin_48796138的博客
04-03 2437
目录🍉 阻塞队列🍉阻塞队列的功能🍉生产者消费者模型🍉生产者消费者模型的优点 🍉 阻塞队列 在学习数据结构时 我们了解到了什么是队列,普通队列遵守先进先出的规则,阻塞队列同样也符合这样的规则,但是相比于普通队列阻塞队列还有着其他的功能 🍉阻塞队列的功能 线程安全:阻塞队列是我们多线程中的案列之一,既然属于多线程,那么一定和线程安全有关系,阻塞队列主要的功能就是能保证线程安全 产生阻塞效果 1.若队列为空,尝试出队列,就会出现阻塞,阻塞到队列不为空为止 2 .若队列为满,尝试如队列也会出现堵塞,阻塞到队列
Java 多线程5——阻塞式队列BlockingQueue的原理 + 消费者生产者模型 + 代码模拟实现
The_emperoor_man的博客
06-26 1000
这篇文章教会你如何使用这个多线程中超级无敌好用的数据结构，带你认识消费者生产者模型，并带你手动用代码实现一个阻塞式队列！！
8、读写锁ReentrantReadWriteLock&StampLock详解.pdf
02-28
6.JUC并发工具类在大厂的应用场景详解 (1).pdf 7、深入理解 AQS 独占锁之 Reentrantlock 源码分析 (1).pdf 8、读写锁ReentrantReadWriteLock&StampLock详解.pdf 9、并发容器 (Map、List、Set） 实战及其原理.pdf 10...
提前批&秋招の笔试面试相关题目分享
02-14
技术面试中，面试官可能会询问计算机网络、JUC（Java并发包）、JVM、Spring框架、设计模式、RabbitMQ、MySQL、Redis等相关知识。 - 面试官也可能考察具体的技术应用，如Spring Cloud、Mybatis/Hibernate、银行系统...
多线程基础、JUC锁、同步容器、线程池
07-11
多线程基础、JUC锁、同步容器、线程池
java并发编程：juc线程池
08-09
JUC线程池的核心类是`ThreadPoolExecutor`，它的主要工作原理如下： 1. 当一个任务被提交给线程池时，线程池首先检查当前运行的线程数是否小于`corePoolSize`。如果是，那么就会创建一个新的工作线程来执行任务。...
《springcloud&学习资料》--JVM、JUC（高并发）、集合、计算机网络、数据库等.zip
最新发布
04-19
JVM、JUC（高并发）、集合、计算机网络、数据库、MySql、Redis、、工作流（Activiti）、规则引擎（Drools）、Spring、SpringCloud、Mybatis、Git、Docker、Utils、Linux 个人花大量时间整理出的实战资料，内容丰富，...
【Java|多线程与高并发】阻塞队列以及生产者-消费者模型
云泽野の编程日记
06-25 1446
阻塞队列(BlockingQueue)常用于多线程编程中，可以实现线程之间的同步和协作。它可以用来解决生产者-消费者问题，其中生产者线程将元素插入队列，消费者线程从队列中获取元素，它们之间通过阻塞队列进行协调。阻塞队列的使用可以简化多线程编程的复杂性，避免手动实现线程间的同步和协作逻辑，提高代码的可读性和可维护性。基于阻塞队列的生产者-消费者模型也要重点掌握.。阻塞队列作为生产者和消费者之间的缓冲区，提供线程安全的插入和获取操作，并在队列为空或队列已满时进行阻塞，从而实现线程间的同步。
生产者-消费者模式（阻塞队列实现）
diweikang的博客
08-01 1978
生产者消费者模式是并发、多线程编程中经典的设计模式，生产者和消费者通过分离的执行工作解耦，简化了开发模式，生产者和消费者可以以不同的速度生产和消费数据。这篇文章我们来看看什么是生产者消费者模式，这个问题也是多线程面试题中经常被提及的。如何使用阻塞队列（Blocking Queue）解决生产者消费者模式，以及使用生产者消费者模式的好处。 真实世界中的生产者消费者模式 生产者和消费者模式在生活当中...
多线程（3）--生产者消费者模式/阻塞队列
m0_62567916的博客
01-25 502
1生产者 消费者模式 1.1 生产者和消费者模式概述 生产者和消费者是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。 所谓生产者消费者的问题，实际上主要包含了两类线程： 一类：是生产者线程用于生产数据。 一类：是消费者线程用于消费数据。 为了解耦生产者和消费者的关系，通常会采用共享数据区域，就像一个仓库。 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者行为。 消费者只需要从共享数据区中去获取数据，并不要关心生产者的行为。 1.2 O
用BlockingQueue实现生产者消费者模式
绅士jiejie的博客
04-18 439
public class TestMain { //定义一个阻塞队列 static BlockingQueue<Object> queue = new ArrayBlockingQueue<>(10); static AtomicInteger producerNumber = new AtomicInteger(0); static Ato...
PriorityBlockingQueue
yueloveme的博客
03-23 439
最近一直在忙公司新业务流程引擎，耽误了最后一个阻塞队列，之后把流程引擎结合springboot总结一下 PriorityBlockingQueue 描述： 带排序的BlockingQueue实现，采用ReentrantLock控制并发，队列为无界队列，与其他阻塞队列不同的是PriorityBlockingQueue只能指定初始队列大小，后面插入元素的时候，如果空间不够的话会自动扩容。Arra...
BlockingQueue阻塞队列实现生产者消费者模式
stackCSDN的博客
04-15 263
package com.hangzhou.springcloud.service.impl; import com.alibaba.fastjson.JSON; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurr...
生产者消费者模式保姆级教程 (阻塞队列解除耦合性) 一文帮你从C语言版本到C++ 版本, 从理论到实现 (一文足以)
小杰312的博客
02-23 2495
生产者消费者模式保姆级教程 (阻塞队列解除耦合性) 一文帮你从C语言版本到C++ 版本, 从理论到实现 (一文足以)
【Linux】多线程同步--基于阻塞队列的生产者消费者模型（条件变量解决）
呋喃吖的博客
05-20 553
文章目录线程同步条件变量条件变量相关接口生产者消费者模型基本理论基于阻塞队列的生产者消费者模型 线程同步 什么是线程同步？ 首先先了解一下：互斥锁带来的一个问题：就是线程饥饿现象：就是多个线程长时间访问不到共享资源，不得已使得线程的执行流得以推进执行，这种现象就是线程饥饿现象！ 有线程饥饿线程的原因就是互斥锁带来的问题！ 有一种场景是，当一个线程A获得锁时候，进入临界区，访问结束后，释放锁，该线程A大概率的竞争能力比其他线程更加强，有可能重新获得锁，再次访问临界区！而其他线程可能竞争力不够强，长时间无法获

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值