Callable,阻塞队列,线程池问题

一.说说 Java 创建多线程的方法

1. 通过继承Thread类实现run方法

2. 通过实现Runnable接口

3. 通过实现Callable接口

4. 通过线程池获取

二. 可以写一个Callable的案例吗?如何调用Callable接口

/*是一个带返回值的多线程类,如果需要有线程返回的结果,就需要使用此类*/
class MyThread implements Callable<Integer> {

    @Override
    public Integer call()  {
        return 1000;
    }
}

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

        /*Thread 构造方法传入 Runnable , FutureTask 构造方法传入 Callable , 
        FutureTask 继承于 RunnableFuture 继承于 Runnable
        所以 Thread通过传入FutureTask即Runnable的实现类来启动Callable线程,
        透传思想,传接口,不传具体的实现类,可以保证灵活性,(适配器模式)
       */
        FutureTask<Integer> ft = new FutureTask(new MyThread());// 一个是main线程,一个是t1线程
        new Thread(ft,"t1").start();


        int res1 = 1000;
        // 获取t1线程中的返回值,建议放在最后
        // 如果没有计算完成就取值,会导致整个程序阻塞,直到t1执行完成
        int res2 = ft.get();
        //自旋锁,如果t1线程没有计算完成,就等待
        while (!ft.isDone()){

        }
        System.out.println(Thread.currentThread().getName() + "\t"+(res1+res2));
    }

三. 请你谈谈对阻塞队列的理解,为什么要是用阻塞队列,它有哪些具体的实现,各有什么特点?

在多线程的环境下,所谓阻塞,在某些情况下会挂起线程,一旦条件满足,被挂起的线程又被唤醒.我们不需要关心

什么时候需要阻塞线程,什么时候需要唤醒线程,一切都有BlockingQueue自动调度实现

它有7个实现类
* 1.ArrayBlockingQueue      由数组构成的有序阻塞队列
* 2.LinkedBlockingQueue     由链表构成的有序阻塞队列
* 3.PriorityBlockingQueue   支持优先级 排序 的无界阻塞队列
* 4.DelayQueue              使用优先级队列的延迟无阻塞队列
* 5.SynchronousQueue        不存储元素的阻塞队列,也即单元素队列
* 6.LinkedTransferQueue     由链表组成的无界阻塞队列
* 7.LinkedBlockingQueue     由链表构成的双向阻塞队列

1,2,5用的最多

BlockingQueue的使用方法

1.会抛出异常

public static void show01(int n){
        /*队列中的数据错误,会抛出异常*/
        /*add     队列满了,再继续插入会抛出java.lang.IllegalStateException: Queue full异常*/
        /*remove  从队列中移除一个元素,并返回该元素,如果队列为空,就抛出java.util.NoSuchElementException异常*/
        /*element 返回队列的首个元素,如果队列为空,抛出java.util.NoSuchElementException异常*/
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(n);
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
//        System.out.println(blockingQueue.add("x"));
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        //System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.element());//
    }

2.不会抛出异常

public static void show02(int n){
        /*队列数据错误,不会抛出异常*/
        /*offer 添加元素,如果队列满了,再继续插入元素,会返回false*/
        /*poll 获取元素,如果队列为空,再继续获取元素,会返回null*/
        /*peek 获取队列的首元素,如果队列为空,返回null*/
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(n);
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
//        System.out.println(blockingQueue.offer("x"));
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
//        System.out.println(blockingQueue.poll());

        System.out.println(blockingQueue.peek());
    }

3.队列阻塞

public static void show03(int n){
        /*队列数据异常,不会抛出异常,没有返回值*/
        /*put 如果队列已满,在插入元素,队列会阻塞*/
        /*take 如果队列为空,在获取元素,队列会阻塞*/
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(n);
        try {
            blockingQueue.put("a");
            blockingQueue.put("b");
            blockingQueue.put("c");
          // blockingQueue.put("x");
            System.out.println("-------------------");
            blockingQueue.take();
            blockingQueue.take();
            blockingQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

4.队列超时 (实际用的较多)

public static void show04(int n){
        /*队列数据异常,不会抛出异常,返回true/false值*/
        /*offer 传入值,等待时间,等待单位,往队列中存放元素,当队列中的元素已满,继续等待,如果超过给定时间,那么就会丢弃元素*/
        /*poll 等待时间,等待单位,从队列中获取元素,当队列中的元素为空,继续等待,如果超过给定时间,那么就不会获取*/
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(n);
        try {
            System.out.println(blockingQueue.offer("a", 2L, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("b", 2L, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("c", 2L, TimeUnit.SECONDS));
            System.out.println(blockingQueue.offer("x", 2L, TimeUnit.SECONDS));

            blockingQueue.poll(2L,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

 public static void main(String[] args) {
        show01(3); //    异常
        show02(3); //   没有异常
        show03(3); //   阻塞
        show04(3); // 超时等待
    }

四.请你谈谈对线程池的理解,为什么要使用线程池,如何使用线程池?

介绍:线程池的主要是控制运行的线程的数量,如果处理过程中将任务加入队列,然后在线程创建的时候启动这些任务.如果线程数量超过了最大数量的线程将排队等候,等待其他的线程执行完毕,再从队列中取出任务来执行.

优点:

1.降低资源消耗,通过复用已创建的线程降低线程创建和销毁造成的消耗

2.提高响应速度,当任务达到时,任务可以不需要等待线程创建就可以立刻执行

3.提高线程的可管理性,线程属于稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性

使用线程池可以进行统一的分配,调优和监控

一句话总结:线程复用,控制最大并发数,管理线程

 public static void show01(ExecutorService es){
        // 创建1个线程池,里面有5个固定的线程
        /*1. 创建一个定长的线程池,可控制线程的最大并发数,超出的线程会在队列中等待
        * 2. newFixedThreadPool创建的线程池corePoolSize和maxPoolSize的值事相等的,使用的是LinkedBlockingQueue
        * */

        es = Executors.newFixedThreadPool(5);

        try{
            // 有10个任务等待被执行
            for (int i = 1; i <= 10; i++) {
                es.execute(()->{
                    System.out.println(Thread.currentThread().getName() +"\t 执行任务");
                });
            }
        }catch (Exception e){
            e.getStackTrace();
        }finally {
            es.shutdown();//关闭线程池
        }
    }

 public static void show02(ExecutorService es){
        // 创建1个线程池,里面有1个固定的线程
        /*
        * 1.创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有的任务按照指定的顺序执行
        * 2.newSingleThreadExecutor将corePoolSize和maxPoolSize的值都设置为1,使用的是LinkedBlockingQueue
        * */
        es = Executors.newSingleThreadExecutor();

        try{
            for (int i = 1; i <= 10; i++) {
                es.execute(()->{
                    System.out.println(Thread.currentThread().getName() +"\t 执行任务");
                });
            }
        }catch (Exception e){
            e.getStackTrace();
        }finally {
            es.shutdown();//关闭线程池
        }
    }

public static void show03(ExecutorService es){
        // 创建1个线程池,里面无固定个线程
        /*
        * 1.创建一个可缓存的线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则创建新线程
        * 2.newCachedThreadPool将corePoolSize的值设置为0,maxPoolSize的值设置为Integer.MAX_VALUE,使用
        *  的是synchronousQueue,也就是说来了任务就创建线程运行,当线程空闲超过60秒,就销毁线程
        *
        * */
        es = Executors.newCachedThreadPool();
        try{
            for (int i = 1; i <= 10; i++) {
                es.execute(()->{
                    System.out.println(Thread.currentThread().getName() +"\t 执行任务");
                });

            }
        }catch (Exception e){
            e.getStackTrace();
        }finally {
            es.shutdown();//关闭线程池
        }
    }

public static void main(String[] args) {
        ExecutorService es = null;
        show01(es);
        show02(es);
        show03(es);
    }

五. 请你谈一谈线程池的七大/五大参数分别代表什么意思

int corePoolSize                      线程池中常驻核心线程数
    * 1.在创建了线程池后,当有请求任务来了之后,就会安排线程池中的线程去执行请求的任务,类似于银行当值的窗口
    * 2.当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中
int maximumPoolSize                   线程池同时能够容纳同时执行的最大线程数,此值必须大于等于1
long keepAliveTime                    多余的空闲线程的存活时间
      * 当前线程池数量超过corePoolSize时,空闲时间达到keepAliveTime值时,多余线程会被销毁直到只剩下corePoolSize个线程为止
      * 默认情况下,只有当线程池中的线程数大于corePoolSize时候keepAliveTime才会起作用,直到线程池中的线程数不大于corePoolSize
      *
TimeUnit unit                         keepAliveTime的单位
BlockingQueue<Runnable> workQueue     任务队列,被提交但尚未被执行的任务
ThreadFactory threadFactory           表示生成线程池中工作线程的线程工厂,用于创建线程,一般用默认的值即可
RejectedExecutionHandler handler      拒绝策略,表示当队列满了并且工作线程大于等于线程池的最大线程数(maximumPoolSize)如何来拒绝请求执行的Runnable策略

六.请你谈一谈线程池的底层工作原理

1.在创建了线程池后,等待提交过来的任务请求

2.当调用execute方法添加一个任务请求时,线程池会做出如下判断:

2.1 如果正在运行的线程数量小于corePoolSize,那么会马上创建这个线程并执行这个任务

2.2 如果此时正在运行的线程数量大于或等于corePoolSize,那么会将这个这个任务放进阻塞队列中等待

2.3 如果此时阻塞队列满了且正在运行的线程数量小于maximumPoolSize,那么会创建非核心线程来立即执行这些任务

2.4 如果此时阻塞队列满了且正在运行的线程数大于或等于maximumPoolSize.那么线程池会启用饱和拒绝策略来拒绝新的请求

3.当一个线程完成任务时,会从阻塞队列中取出下一个任务来执行

4.此时当一个线程空闲并超过一定的时间keepAliveTime,此时线程池会判断,如果当前运行的线程数量大于corePoolSize,那么这些线程将会被终止.

所以线程池的所有任务完成后,最终会收缩到corePoolSize的大小.

举列子:银行办理业务,周六招商银行,一共有5个柜面,只开放了2个柜台办理业务,此时2就代表corePoolSize,5个柜台代表了maximumPoolSize,只有2个员工在干活,

其他的3个柜台都是空闲的当有人来进去办业务,如果来的人少于2人可以立即办理业务,无需等待,当来了5个人办理业务,前面的1,2号没有办完,此时3,4,5号就

会进入候客区等待.也就是线程池中的阻塞队列中等待被执行.如果此时来银行办理业务的任实在太多,来了7,8,9,候客区也满了(BlockingQueue满了),此时银行

行长就会开放剩余的柜台来处理业务(非核心线程打开,此时线程数达到最大值),打电话给另外3个柜员来加班,此时柜台全部开放,也满足不了新的客户需求,那么

最后银行行长就会暂时关闭这个网点(拒绝策略拒绝新的请求),先来办理行内的业务.当解决了一个任务时,就会叫下一个号来办理业务(从阻塞队列中获取待

解决的任务).如果过了一个小时(keepAliveTime保留活跃时间),银行的流量下降了,此时,加班的3个人可以先回去(本来也不该他们上班),银行重新回归到初始状

态.(这么说,小伙伴们懂了吗~)

七. 请你谈一谈线程池的拒绝策略

此时线程池中的阻塞队列已经被塞满,再也放不进新的任务,同时线程数也达到了maximumPoolSize,无法为新的请求服务,此时JDK有4种拒绝策略

1.AbortPolicy(默认)    直接抛出RejectedExecutionException异常阻止系统正常运行
2.CallersRunsPolicy    "调用者模式"一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将某些任务回退到调用者,从而降低新任务的流量
3.DiscardOldestPolicy  抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交当前任务
4.DiscardPolicy        直接丢弃任务,不予处理也不抛出异常.如果允许任务丢失,这是最好的一种方案

那此时可以说下在工作中用了哪一种线程池?(此处有坑)

JDK提供的线程池一律不能说,标准答案: 根据业务的需要,自定义ThreadPoolExectuor来创建线程池.

public static void show04(ExecutorService es){
       // 核心线程数为2,最大线程数为5,非核心线程的最大运行时间是1秒
       // 阻塞队列中一共有3个等待的任务,使用默认的线程生成策略,同时开启
       // 调用者模式的拒绝策略
       es = new ThreadPoolExecutor(
                2,5,1L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        try{
            for (int i = 1; i <= 10; i++) { // 开启10个请求,最大线程数量是8,
                es.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t办理业务");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            es.shutdown();
        }
    }

运行结果:

AbortPolicy,直接抛出异常

CallersRunsPolicy 不会抛出异常,返回给方法的调用者,也就是main线程

DiscardOldestPolicy  抛弃队列中等待最久的任务

DiscardPolicy 直接抛弃队列中多余的任务,如果业务允许,此拒绝策略效率最高

八. 请你谈一谈,如何在实际的生产业务中确定线程池中参数的配置

此时要根据实际做的系统进行分类

1.CPU密集型

/*指的是该任务需要大量的运算,没有阻塞,CPU一直全速运行,CPU密集任务只有真正的多核心CPU才能得到加速(通过多线程)而在单核CPU上
   无论开几个模拟多线程的任务都不可能得到加速,因为CPU的运算能力有限.
    1.CPU密集型的任务尽可能少配线程数量
    2.公式:线程数 = CPU核心数 + 1个线程的线程池(8核就开启8个线程,12核开启12个线程,尽量减少切换)
    3.System.out.println(Runtime.getRuntime().availableProcessors());//查看CPU的核心数*/

2.I/O密集型

/* 1.I/O密集型并不是在一直执行任务,应该配置尽可能多的线程,线程数 = CPU核心数 * 2
   2.I/O密集型即该任务需要大量的I/O操作,业务系统中大量的阻塞(从数据库,缓存获取数据,修改数据...)
      所以在I/O密集型的场景中,使用多线程可以大大加速程序运行,即使在单核CPU上,这种加速也可以利用了被浪费掉的阻塞时间
      因为大部分线程都会阻塞,需要配置大量的线程数 
      线程数 = CPU核心数 / 1-阻塞系数 阻塞系数在0.8~0.9之间
      (例如 8核心CPU 8 / 1 - 0.9 = 80,如果是I/O密集型的操作,需要配置80个线程数) 
*/