线程面试：中级篇

dev晴天

已于 2022-08-11 17:43:18 修改

阅读量100

点赞数

分类专栏： Android InterView 文章标签：面试 java

于 2021-06-08 21:08:46 首次发布

本文链接：https://blog.csdn.net/qq_38350635/article/details/117715395

版权

Android InterView 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

本节复习点

1、带返回结果的线程

2、线程池及其工作流程

3、各种锁（这里就先练习为主）

4、并发包

5、原子类

6、锁的应用BlockingQueue的实现

     a、使用synchronized实现

     b、使用ReentrantLock实现

一、带返回结果的线程Callable 和 Future 创建线程

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

        // 1、创建Callable实现类，实现call接口
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int a = 1;
                int b = 2;
                return a+b;
            }
        };

        //2、创建FutureTask 实例，传参callable。（其实FutureTask 就是Runnable的实现类）
        FutureTask<Integer> futureTask = new FutureTask<>(callable);

        // 3、借助Thread执行，Runnable实现类传参给Thread。
         new Thread(futureTask).start();

         // 4、获取结果可从futureTask的get获取
        System.out.println("获取执行结果："+futureTask.get());
    }

1、分析Callable是一个泛型接口，可以返回任意类型的返回值。作为参数传参给FutureTask，FutureTask是Runnable实现类对象，当Thread执行runnable的run方法时就会执行FutureTask 的callable run逻辑。

FuntureTask 接口的核心方法为get方法，这个方法会一直等待结果完成（内部通过awaitDone 来使用LockSupport实现线程阻塞，等待获取结果状态，LockSupport底层就是UNSAFE类了直接通过native层来实现）。然后返回结果。

2、Future接口表示一个未来可能会返回的结果，它定义的方法有如下方法。具体的实现都在实现类FutureTask类中:

      a、get()：获取结果（可能会等待）
      b、get(long timeout, TimeUnit unit)：获取结果，但只等待指定的时间；
      c、cancel(boolean mayInterruptIfRunning)：取消当前任务；
      d、isDone()：判断任务是否已完成。

3、总结

使用Future获得异步执行结果时，要么调用阻塞方法get()，要么轮询看isDone()是否为true，这两种方法都不是很好，因为主线程也会被迫等待。

从Java 8开始引入了CompletableFuture，它针对Future做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。

二、线程池及其工作流程

 ThreadPoolExecutor(          int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

1、为啥使用线程池？

Java语言虽然内置了多线程支持，启动一个新线程非常方便，但是创建线程需要操作系统资源（线程资源，栈空间等），频繁创建和销毁大量线程需要消耗大量时间。这时就需要使用线程池来进行管理了。

2、线程池有哪些优点？

（1）降低资源消耗：通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗。

（2）提高响应速度：任务到达时，无需等待线程创建即可立即执行。

（3）提高线程的可管理性：线程是稀缺资源，如果无限制创建，不仅会消耗系统资源，还会因为线程的不合理分布导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控。

（4）提供更多更强大的功能：线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行。

3、继承关系

在这里插入图片描述

Excutors 提供了几种默认的线程池。线程池都是基于ThreadPoolExcutor构造传不同的参数进行封装。

4、启动策略

线程池创建时是不会创建线程的，只有把runnable 传递给 execute时线程池才会创建线程。

在这里插入图片描述
当任务来临时：

a：判断任务个数TaskCount是否大于核心池corePoolSize大小。

当任务个数小于核心池大小，在核心池创建TaskCount 个线程，并执行任务。
当任务个数大于核心池大小，大于的任务个数extra1（TaskCount-corePoolSize = extra1）提交到工作队列

b：假如工作队列大小为queueCount。

queueCount>extra1时,extra1都存储在工作队列中，等待核心池任务执行完毕，复用线程放入核心池执行。
queueCount<extra1时此时工作对了还是容纳不了，多余的任务为extra1-queueCount = extra2：多余的任务extra2进入最大池：

c：maxPoolSize逻辑对比

当extra2<maxPoolSize时，在maxPoolSize中创建 maxPoolSize-queueCount个线程，执行任务。
当extra2>maxPoolSize 时，在max线程池中申请maxPoolsize-queueCount-minPoolSize 个线程。多余时抛出异常。

注意：保活时间是当线程池中的线程个数大于corePoolSize时额外空闲线程的存活时间。

5、线程池启动策略栗子

  private static final ThreadPoolExecutor executor = 

   new ThreadPoolExecutor(5,
                          10, 
                          1, 
                          TimeUnit.SECONDS,
                           new ArrayBlockingQueue<>(2));

           for (int i = 0; i < n; i++) { 
              executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        method();
                        System.out.println("线程池中线程数目: " + executor.getPoolSize() + " 队列中等待执行的任务数: "
                                + executor.getQueue().size() + " 已执行完的任务数: " + executor.getCompletedTaskCount());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
             }

a、当任务n = 4时(n<=corePoolSize)：此时在核心池创建4个线程。线程池线程个数4

b、当任务n = 6（corePoolSize<n），此时多余的一个任务进入工作队列。线程池个数5，工作队列1。

c、当任务n = 8(corePoolSize+工作队列个数还是小于 n) 此时多余的在最大池创建，这时线程池任务个数7个（核心池5+最大池2），工作队列1个注意多余的才在最大池创建。工作队列的还在等待。

ps：这里需要明白一点，工作队列足够大，最大池就不会创建，例如Excutor的提供的好几个线程池就是使用了LinkedBlockQueue 直接以链表的形式，无线缓冲任务。

d、当最大池也满了则抛出异常。

修改工作队列满足个数进行测试:

lass ThreadPoolsDemo {
    static final int mCount = Runtime.getRuntime().availableProcessors();


    private static final ThreadPoolExecutor executor =
            new ThreadPoolExecutor(5, 10, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(20)); // 这里使用的数组工作队列，个数固定，不支持扩充的数组。

    public static void main(String[] args) {

        System.out.println("cpu核心："+mCount);
        for (int i = 0; i < 20; i++) { //11 正好，12时超过最大池的限制。这时抛异常（RejectedExecutionException）
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        method();
                        System.out.println("线程池中线程数目: " + executor.getPoolSize() + " 队列中等待执行的任务数: "
                                + executor.getQueue().size() + " 已执行完的任务数: " + executor.getCompletedTaskCount());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }


    }


    private static void method() throws InterruptedException {
        System.out.println("ThreadName" + Thread.currentThread().getName() + "进来了");
        Thread.sleep(1000);
        System.out.println("ThreadName" + Thread.currentThread().getName() + "出去了");
    }
}

6、Java标准库还提供了一个java.util.Timer类，这个类也可以定期执行任务，但是，一个Timer会对应一个Thread，所以，一个Timer只能定期执行一个任务，多个定时任务必须启动多个Timer，而一个ScheduledThreadPool就可以调度多个定时任务，所以，我们完全可以用ScheduledThreadPool取代旧的Timer。

7、线程池的拒绝策略

     //线程池默认使用的拒绝策略
    private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
   
    public static class AbortPolicy implements RejectedExecutionHandler {

        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }  
       
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

jdk提供了RejectedExecutionHandler接口，并且定义了rejectedExecution方法来定制拒绝策略，jdk提供了四个默认实现策略：

AbortPolicy :拒绝任务，并且抛出RejectedExecutionException异常。异常需要显式处理否则影响后续任务执行。jdk默认策略。
CallerRunsPolicy：触发拒绝策略时，若线程池未shutdown则直接在调用者线程中执行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大
DiscardPolicy：触发拒绝策略丢弃任务，其他啥也不做。
DiscardOldestPolicy：触发拒绝策略时，丢弃任务队了中最老的任务，并尝试执行新的任务。

参考：
https://www.jianshu.com/p/d7d41e1ae40d

https://www.cnblogs.com/amunote/p/10322294.html

三、各种锁

从Java 5开始，并发包（java.util.concurrent），它提供了大量更高级的并发功能类，能大大简化多线程程序的编写。java语言提供了synchronized锁。

synchronized是java语言层面的锁，这个锁有弊端：一个重量级的锁，获取时需要一直等待其他线程释放锁，没有额外尝试机制。

1.5开始提供并发包提供Lock来解决synchronized的弊端。

在这里插入图片描述

1、ReadWriteLockReentrantLock

可重入锁：一个线程可以多次获取同一把锁。
轻量级锁：具备尝试机制，避免一直等待。
java 代码实现，必须手动获取、释放锁。当然需要考虑异常。
在jdk1.5里面，ReentrantLock的性能是明显优于synchronized的，但是在jdk1.6里面，synchronized做了优化，他们之间的性能差别已经不明显了。
公平锁ReentrantLock(boolean fair)：构造传参开启。一般意义上的锁是不公平的，不一定先来的线程能先得到锁，后来的线程就后得到锁。公平锁的意思就是，这个锁能保证线程是先来的先得到锁。虽然公平锁不会产生饥饿现象，但是公平锁的性能会比非公平锁差很多。
不能配合wait、notify需要配合condition来完成线程同步。
使用ReentrantLook的tryLook更安全，在规定时间内获取不到锁时不会一直等待下去，可避免死锁的发生。

Condition：
（1）使用Condition时，引用的Condition对象必须从Lock实例的newCondition()返回。

（2）Condition提供的await()、signal()、signalAll()原理和synchronized锁对象的wait()、notify()、notifyAll()是一致的，并且其行为也是一样的：

await()会释放当前锁，进入等待状态；
signal()会唤醒某个等待线程；
signalAll()会唤醒所有等待线程；

应用场景：通过ReentrantLock和Condition实现了一个BlockingQueue。

BlockingQueue的意思就是说，当一个线程调用这个TaskQueue的getTask()方法时，该方法内部可能会让线程变成等待状态，直到队列条件满足不为空，线程被唤醒后，getTask()方法才会返回。因为BlockingQueue非常有用，所以我们不必自己编写，可以直接使用Java标准库的java.util.concurrent包提供的一些列线程安全的集合。

2、 ReadWriteLock（悲观锁）：可以解决多线程同时读的问题。

因为我们发现，使用ReentrantLock，或者Synchronized时，任何时刻只允许一个线程操作（读或者写）资源。当我们碰到多个线程修改资源时使用上述锁无问题，但是当多个线程去读取资源时上述的锁就有些保护过度了，实际场景应该是可以允许多线程同时读。于是并发包提供了ReadWriteLock。

ReadWriteLock锁的特点：

一个线程写入时，其他线程既不能写入也不能读取；
没有写入时，多个线程允许同时读（提高性能）
读的过程中不允许写操作。
适合读多写少的场景

总结：使用ReadWriteLock时，适用条件是同一个数据，有大量线程读取，但仅有少数线程修改。把读写操作分别用读锁和写锁来加锁，在读取时，多个线程可以同时获得读锁，这样就大大提高了并发读的执行效率。

例如，一个论坛的帖子，回复可以看做写入操作，它是不频繁的，但是，浏览可以看做读取操作，是非常频繁的，这种情况就可以使用ReadWriteLock。

3、StampedLock（乐观锁）

ReadWriteLock可以解决多线程同时读，但只有一个线程能写的问题。它有个潜在的问题：如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，即读的过程中不允许写，这是一种悲观的读锁。

进一步提升并发执行效率，Java 8引入了新的读写锁：StampedLock。改进之处在于：读的过程中也允许获取写锁后写入！这样一来，我们读的数据就可能不一致，所以，需要一点额外的代码来判断读的过程中是否有写入，这种读锁是一种乐观锁。

乐观锁：乐观地估计读的过程中大概率不会有写入，因此被称为乐观锁。反过来，悲观锁则是读的过程中拒绝有写入，也就是写入必须等待。显然乐观锁的并发效率更高，但一旦有小概率的写入导致读取的数据不一致，需要能检测出来，再读一遍就行，所以，需要一点额外的代码来判断读的过程中是否有写入。

StampedLock把读锁细分为乐观读和悲观读，能进一步提升并发（读写）效率。

代价：代码更加复杂，读的过程需要增加额外判断逻辑。判断是否有写入。
代价：StampedLock是不可重入锁，不能在一个线程中反复获取同一个锁
好处：可以解决多线程同时读，但只有一个线程能写的问题。允许读的过程中可以有写操作。
StampedLock提供了乐观读锁，可取代ReadWriteLock以进一步提升并发性能。

锁	类型
synchronized	重量级锁、可重入锁、同步锁、互斥锁
ReentrantLock	轻量级锁、公平锁（true）、非公平锁（false）
StampedLock	乐观锁
ReadWriteLock	悲观锁

参考文章：java中的各种锁总结(简单全面版)

四、Concurrent 集合

Java标准库的java.util.concurrent包提供的线程安全的集合：BlockingQueue。除了BlockingQueue外，针对List、Map、Set、Deque等，java.util.concurrent包也提供了对应的并发集合类。我们归纳一下：

interface	non-thread-safe	thread-safe
List	ArrayList	CopyOnWriteArrayList
Map	HashMap	ConcurrentHashMap
Set	HashSet / TreeSet	CopyOnWriteArraySet
Queue	ArrayDeque / LinkedList	ArrayBlockingQueue / LinkedBlockingQueue
Deque	ArrayDeque / LinkedList	LinkedBlockingDeque

Collections工具类还提供了一个旧的线程安全集合转换器，但是它实际上是用一个包装类包装了非线程安全的集合，然后对所有读写方法都用synchronized加锁，这样获得的线程安全集合的性能比java.util.concurrent集合要低很多，所以不推荐使用。

五、Atomic 原子类

Java的java.util.concurrent包除了提供底层锁、并发集合外，还提供了一组原子操作的封装类，它们位于java.util.concurrent.atomic包。

特点：Atomic类是通过无锁（lock-free）的方式实现的线程安全（thread-safe）访问。它的主要原理是利用了CAS：Compare and Set。

例子：例如代表类AtomicInteger的++等操作，通过CAS机制对相关操作进行封装，提供相应的api，提供的api就是原子性操作。

  class Atomic {

    private static final AtomicInteger count = new AtomicInteger();

    private static int num =0;

    public static void main(String[] args) {

        for (int i = 0; i < 20; i++) {
            new Thread(Atomic::plusPlus).start();
        }
    }

    /**
     * 数值操作++
     */
    public static void plusPlus() {
        // 打印的数值从0 逐渐递增
        System.out.println(Thread.currentThread().getName() + "获取++值：" + count.incrementAndGet()); // 保证了++操作的原子性

        // 打印数值不精确，有的值线程已经修改，其他线程访问还是未修改的。
        //  System.out.println(Thread.currentThread().getName() + "获取++值：" + (num++)); // ++操作不是原子性
    }
}

原子类特点：

原子操作实现了无锁的线程安全；
适用于计数器，累加器等。

六、锁的应用BlockingQueue简单实现

BlockingQueue：队列读取数据时如果为空会一直等待，当队列中有新的元素时唤醒等待线程，下次读取就不用等待直接读取。

1、synchronized方式实现：



    class TaskQueue {
    Queue<String> queue = new LinkedList<>();

    public synchronized void addTask(String s){
          this.queue.add(s);
          this.notifyAll();//2、通知wait的所有线程唤醒。
    }

    public synchronized String getTask(){ // 线程会获取this锁
        while (queue.isEmpty()){
            try {
                this.wait(); //1、线程释放this锁，其他线程就可以获取this锁操作getTask，或者addTask。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return queue.remove();
    }
}

2、ReentrantLock 实现方式

   

    class TaskQueueByReentrantLock {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    Queue<String> queue = new LinkedList<>();

    public void addTask(String s) {
        lock.lock();
        try {
            this.queue.add(s);
            condition.signalAll(); // 唤醒休眠的线程
        } finally {
            lock.unlock();
        }

    }

    public String getTask() throws InterruptedException {
        lock.lock(); //锁的开始代码块
        try {
            while (queue.isEmpty()) {
                condition.await(); // 释放锁。
            }
            return queue.remove();
        } finally {
            lock.unlock(); //锁的结束代码块。（lock、unlock不要理解为获取，释放锁）
        }
    }

}

dev晴天

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
线程面试：中级篇

本节复习点1、带返回结果的线程2、线程池及其工作流程3、各种锁（这里就先练习为主）4、并发包5、原子类6、锁的应用BlockingQueue的实现 a、使用synchronized实现 b、使用ReentrantLock实现一、带返回结果的线程Callable 和 Future 创建线程 public static void main(String[] args) throws ExecutionException, InterruptedExcepti
复制链接

扫一扫