栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java并发编程JUC(四) 阻塞队列 线程池 分支合并 异步回调

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java并发编程JUC(四) 阻塞队列 线程池 分支合并 异步回调

一 阻塞队列 栈与队列的区别

阻塞队列 BlockingQueue

  • 当队列是空的,从队列中获取元素的操作将会被阻塞
  • 当队列是满的,从队列中添加元素的操作将会被阻塞
阻塞队列分类

阻塞队列核心方法

package new_course.chp4.queue;

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


public class BlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        //创建阻塞队列
        BlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        //第一组
        System.out.println(blockingQueue.add("a")); //true
        System.out.println(blockingQueue.add("b")); //true
        System.out.println(blockingQueue.add("c")); //true
        System.out.println(blockingQueue.element());//a
//        System.out.println(blockingQueue.add("d")); //Exception in thread "main" java.lang.IllegalStateException: Queue full
        System.out.println(blockingQueue.remove());//a
        System.out.println(blockingQueue.remove());//b
        System.out.println(blockingQueue.remove());//c
//        System.out.println(blockingQueue.remove());//Exception in thread "main" java.util.NoSuchElementException

        //第二组
        System.out.println(blockingQueue.offer("a")); //true
        System.out.println(blockingQueue.offer("b")); //true
        System.out.println(blockingQueue.offer("c")); //true
        System.out.println(blockingQueue.offer("ww")); //false,当队列满,offer不会报错,而add会报错
        System.out.println(blockingQueue.poll());//a
        System.out.println(blockingQueue.poll());//b
        System.out.println(blockingQueue.poll());//c
        System.out.println(blockingQueue.poll());//null 当队列空,poll不会报错,而remove会报错

        //第三组
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
//        blockingQueue.put("w");//阻塞,直到队列有位置
        blockingQueue.take();
        blockingQueue.take();
        blockingQueue.take();
//        blockingQueue.take();//阻塞,直到队列有元素

        //第四组
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("w",3L, TimeUnit.SECONDS)); //超过时间没放进去自动退出
    }

}
二 线程池 为什么使用线程池

三种线程池的声明
package new_course.chp4.threadpool;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


public class MyThreadPoolDemo {
    public static void main(String[] args) {
        //一个线程池,五个工作线程,类似一个银行有五个窗口受理点
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);

        //一个线程池,一个工作线程,类似一个银行有一个窗口受理点
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();

        //以上两种都不好,因为总有不满足的情况,最好的情况是要有扩容
        //一个线程池,N个工作线程,类似一个银行有N个窗口受理点
        ExecutorService threadPool = Executors.newCachedThreadPool();

        try {
            //模拟有10个顾客过来银行办理业务,目前池子里面有五个工作人员提供服务
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "t 办理了业务");
                });
                try {TimeUnit.MILLISECONDS.sleep(8);} catch (InterruptedException e) { e.printStackTrace(); }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭线程池
            threadPool.shutdown();
        }
    }
}

ThreadPool底层原理

线程池7大参数

源码解读:

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue 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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

corePoolSize:常驻核心线程数

比如周一至周五银行有五个窗口,corePoolSize = 5,然而周日业务没有那么繁忙,所以只开了一个窗口,这时候corePoolSize = 1。

maximumPoolSize:线程池中,所能容纳的最大线程数

maximumPoolSize 值必须>=1

keepAliveTime:等待的时间数 unit:时间单位

TimeUnit.SECONDS

workQueue:阻塞队列

相当于去银行办理业务,窗口都满了,需要把人员带到后客厅,侯客厅相当于是阻塞队列

threadFactory:线程工厂

一般用默认的,相当于一个牌子

handler:拒绝策略

拒绝策略,当工作线程 > maximumPoolSize 的时候,如何来拒绝请求执行的Runnable策略

JDK内置的拒绝策略:

线程池底层工作原理

阿里巴巴Java开发手册-并发控制注意事项

三 分支合并
package new_course.chp4.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 = new MyTask(0, 100);

        ForkJoinPool threadPool = new ForkJoinPool();
        //递交任务
        ForkJoinTask forkJoinTask = threadPool.submit(myTask);

        System.out.println(forkJoinTask.get());
        threadPool.shutdown();
    }
}

class MyTask extends RecursiveTask {

    //10以内不要forkjoin
    private static final Integer ADJUST_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() {
        if ((end - begin) <= ADJUST_VALUE) {
            for (int i = begin; i <= end; i++) {
                result += i;
            }
        } else {
            int middle = (end + begin) / 2;
            //一个任务算一部分
            MyTask task01 = new MyTask(begin, middle);
            MyTask task02 = new MyTask(middle + 1, end);
            task01.fork();//重复递归调用compute
            task02.fork();
            result = task01.join() + task02.join();
        }
        return result;
    }
}
四 异步回调
package new_course.chp4.completablefuture;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;


public class CompletableFutureDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture completableFuture = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "没有返回 update mysql ok");
        });
        completableFuture.get();

        CompletableFuture integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "有返回, insert mysql ok");
            return 1024;
        });
        integerCompletableFuture.whenComplete((t,u) -> {
            System.out.println("*********t: " + t);
            System.out.println("*********u: " + u);
        }).exceptionally((throwable -> {
            System.out.println("**************"+throwable);
            return 4444;
        }));
    }

}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/980661.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号