java面试——juc篇

一、线程基础

1、进程与线程的区别？（???）

• 进程：进程是程序的一次执行过程，是操作系统资源分配的基本单位。程序由指令和数据组成，指令要运行就得加载至CPU，数据要读写就得加载至内存，在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存以及IO 的。
• 线程：一个线程就是一个指令流，是操作系统中最小的调度单位，负责将指令流中的一条条指令以一定的顺序交给 CPU 执行。
• 两者区别：
  • 关系：进程是正在运行程序的实例，进程中包含了线程，每个线程执行不同的任务。
  • 内存：不同的进程使用不同的内存空间，同一进程下的所有线程共享内存空间。
  • 开销：线程更轻量，线程上下文切换开销要比进程上下文切换开销低。

2、并行和并发的区别（?）

• 并发：两个及两个以上的作业在同一?时间段?内执行。
• 并行：两个及两个以上的作业在同一?时刻?执行。

3、创建线程的方式有哪些？（????）

• 继承Thread类
• 实现runnable接口
• 实现Callable接口
• 线程池创建线程

runnable和Callable的区别：

• Runnable 接口 run 方法没有返回值； Callable 接口 call 方法有返回值，是个泛型，和Future 、 FutureTask 配合可以用来获取异步执行的结果。
• Callalbe 接口支持返回执行结果，需要调用 FutureTask.get() 得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。
• Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部使用try-catch消化，不能继续上抛。

线程中的run()和 start()的区别：

• start():用来启动线程，通过该线程调用run方法执行run方法中所定义的逻辑代码。start方法只能被调用一次。
• run():封装了要被线程执行的代码，可以被调用多次。

????????调用?start()?方法方可启动线程并使线程进入就绪状态，直接执行?run()?方法的话不会以多线程的方式执行，会把?run()?方法当成一个 main 线程下的普通方法去执行。

4、线程的状态及其生命周期（????）

• 新建状态(New)：线程对象被创建出来，但没有执行start()。
• 可执行状态(RUNNABLE)：线程调用start()方法转为可执行状态。
• 阻塞状态(Blocked)：没有获取锁则进入阻塞状态，获得锁再切换为可执行状态。
• 等待状态(wating)：线程调用了wait()方法进入等待状态，其他线程调用notify()唤醒后可切换为可执行状态。
• 超时等待状态(TIME_WAITING)：线程调用了sleep(50)方法，进入计时等待状态，到时间后可切换为可执行状态。
• 终止状态(TERMINATED)：该线程已经运行完毕。

5、新建 T1、T2、T3 三个线程，如何保证按顺序执行？（???）

????????使用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。

如：在t2线程里添加代码:t1.join(); 在t3线程里添加代码t2.join()；

6、notify()和 notifyAll()的区别（??）

• notifyAll：唤醒所有wait的线程
• notify：随机唤醒一个 wait 线程

7、sleep() 方法和 wait() 方法的异同（???）

• 相同点：都可以让线程进入阻塞状态。
• 不同点：
  • 方法归属：sleep是Thread的静态本地方法，wait()是Object类的本地方法。
  • 醒来时机：sleep执行完线程会自动苏醒；wait需要其他线程调用notify或notifyAll。
  • 锁特性：调用wait方法需要获取对象锁，唤醒后会释放锁；调用sleep不需要获取锁也不会释放锁。

8、如何停止一个正在运行的线程？（??）

• 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
• 使用stop方法强行终止（不推荐，方法已作废）。
• 使用interrupt方法中断线程。

---

二、线程中的并发安全

9、synchronized关键字的底层原理（???）

• synchronized用于解决多线程的并发安全问题，可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。
• synchronized底层是由monitor实现的，在线程获取锁成功过后需要和monitor对象进行关联，即将对象头的mark word字段存储monitor的地址，并将monitor的owner字段指向该线程。
• 由于monitor是操作系统级别的对象，在实现线程之间的切换时需要从用户态转换到内核态，成本较高，因此synchronized属于?重量级锁，效率低下。 jdk1.6之后引入了锁升级减少了锁的开销，如：轻量级锁、偏向锁等。
  • monitor有三个字段：
    • Owner：存储当前获取锁的线程的，只能有一个线程可以获取。
    • EntryList：关联没有抢到锁的线程，处于Blocked状态的线程。
    • WaitSet：关联调用了wait方法的线程，处于Waiting状态的线程 。
  • 对象头有两个字段：
    • Mark word：如下图。
    • Klass word：对象的类。

synchronized的使用

• 修饰实例方法
• 修饰代码块
• 修饰静态方法

10、谈谈 JMM（Java 内存模型）（???）

? ? ? ? 首先搞清楚java内存区域和java内存模型的区别：

• java内存区域：定义的是jvm在运行时如何如何分区存储程序数据。
• java内存模型：和java并发编程相关，描述了Java程序中各种变量(线程共享变量)的访问规则
  ，目的是为了简化多线程编程。

• 所有的共享变量都存储于主内存，这里所说的变量指的是实例变量和类变量。不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。
• 每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。
• 线程对变量的所有操作(读，写)都必须在工作内存中完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程之间交互需要通过主内存完成。

11、谈谈CAS（???）

????????CAS全称是： Compare And Swap(比较再交换)，它体现的是一种乐观锁的思想， 在无锁情况下保证多线程操作共享数据的原子性。

? ? ? ? 具体实现如下图：

? ? ? ? 当线程A对共享变量a进行++操作时，需要将a读入工作内存，执行++操作，再进行CAS操作，发现旧数据A和共享数据V相等， 于是修改成功，将新值写入主内存； 而线程B想进行- -操作，再进行CAS操作时，发现不相等，于是开始重复这个过程(自旋操作)。?

悲观锁和乐观锁的区别：

• 悲观锁：悲观锁总是假设最坏的情况，认为共享资源每次被访问的时候就会出现并发安全问题，所以每次在获取资源操作的时候都会上锁，这样其他线程想拿到这个资源就会阻塞直到锁被上一个持有者释放。也就是说，共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程。 如synchronized。
• 乐观锁：乐观锁总是假设最好的情况，认为共享资源每次被访问的时候不会出现问题，线程可以不停地执行，无需加锁也无需等待，只是在提交修改的时候去验证对应的数据是否被其它线程修改了。? 如CAS。

12、谈谈volatile（???）

? ? ? ? 当一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

• 保证线程间的可见性：一个线程修改了某个变量的值，该新值对其他线程来说是立即可见的。
  • volatile关键字可以保证变量的可见性，如果我们将变量声明为?volatile，这就指示 JVM，这个变量是共享且不稳定的，每次使用它都到主存中进行读取。
• 禁止指令重排序：用 volatile 修饰共享变量会在读、写共享变量时加入不同的屏障，阻止其他读写操作越过屏障，从而达到阻止重排序的效果。

13、谈谈AQS（???）

????????AQS全称AbstractQueuedSynchronizer，即抽象队列同步器。它是构建锁或者其他同步组件的基础框架，常见的实现类有：ReentrantLock(阻塞式锁)、Semaphore(信号量)、CountDownLatch(倒计时锁)。AQS与Synchronized的区别如下图：

AQS的实现：

• AQS内部维护了一个先进先出的双向队列，队列中存储的排队的线程。
• AQS内部还维护了一个属性state，相当于资源，默认为0(无锁状态)。当有线程修改了state为1，则该线程获取了资源。
• 使用CAS操作保证各线程对state修改的原子性。

14.1、谈谈ReentrantLock（???）

• ReentrantLock表示可重入锁，同一线程可多次获取锁。
• ReentrantLock主要利用CAS+AQS队列来实现。
• ReentrantLock支持公平锁和非公平锁，在提供的构造器的中无参默认是非公平锁，也可以传参设置为公平锁。

14.2、CountDownLatch是什么？什么场景下使用？（????）

????????CountDownLatch允许 count 个线程阻塞在一个地方，直至所有线程的任务都执行完毕。

????????CountDownLatch(倒计时锁)是AQS的实现类之一，默认构造 AQS 的 state 值为 count。当线程使用 countDown() 方法时,即以 CAS 的操作来减少 state,直至 state 为 0 。当调用 await() 方法的时候，如果 state 不为 0，即任务还没有执行完毕，await() 方法就会一直阻塞，直到state 值被减为 0，该线程才会从阻塞中被唤醒，await() 方法之后的语句得到执行。

????????使用场景：项目中有一个使用多线程读取多个文件处理的场景用到了?CountDownLatch。

????????我们要读取处理 6 个文件，这 6 个任务都是没有执行顺序依赖的任务，但是我们需要返回给用户的时候将这几个文件的处理的结果进行统计整理。

????????为此我们定义了一个线程池和 count 为 6 的 CountDownLatch 对象 。使用线程池处理读取任务，每一个线程处理完之后就将 count-1，调用CountDownLatch 对象的 await()方法，直到所有文件读取完之后，才会接着执行后面的逻辑。 伪代码如下：

public class CountDownLatchExample1 {
    // 处理文件的数量
    private static final int threadCount = 6;

    public static void main(String[] args) throws InterruptedException {
        // 创建一个具有固定线程数量的线程池对象（推荐使用构造方法创建）
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        for (int i = 0; i < threadCount; i++) {
            final int threadnum = i;
            threadPool.execute(() -> {
                try {
                    //处理文件的业务操作
                    //......
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //表示一个文件已经被完成
                    countDownLatch.countDown();
                }

            });
        }
        countDownLatch.await();
        threadPool.shutdown();
        System.out.println("finish");
    }
}

14.3、谈谈Semaphore?（???）

????????synchronized?和?ReentrantLock都是一次只允许一个线程访问某个资源，Semaphore?(信号量)可以控制同时访问特定资源的线程数量，通常用于那些资源有明确访问数量限制的场景比如限流。

????????Semaphore 的使用：假设有 N个线程来获取 Semaphore 中的共享资源，以下代码表示同一时刻 只有N 个线程能获取到共享资源，其他线程都会阻塞。直到有线程释放了共享资源，其他阻塞的线程才能获取到资源。

// 初始共享资源数量
final Semaphore semaphore = new Semaphore(5);
// 获取1个许可
semaphore.acquire();
// 释放1个许可
semaphore.release();

Semaphore?有两种模式：

• 公平模式：?调用?acquire()?方法的顺序遵循 FIFO；
• 非公平模式：?抢占式的。

15、synchronized和Lock有什么区别 ?（????）

• 语法层面：
  • synchronized是关键字，用 c++ 语言实现 。
  • Lock是接口，用 java 语言实现。
  • 使用synchronized 时，退出同步代码块锁会自动释放，而使用 Lock 时，需要手动调用 unlock 方法释放锁。
• 功能层面：
  • 二者均属于悲观锁、都具备基本的互斥、同步、锁重入功能。
  • LOCK提供了许多 synchronized 不具备的功能，例如获取等待状态、公平锁、可打断、可超时、多条件变量。
  • LOCK有适合不同场景的实现，如 ReentrantLock，ReentrantReadWriteLock
• 性能层面：
  • 在没有竞争时：synchronized 做了很多优化，如偏向锁、轻量级锁，性能不赖。
  • 在竞争激烈时：Lock 的实现通常会提供更好的性能。

16、什么是线程死锁?如何避免死锁?（???）

????????线程死锁：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不能正常终止。

产生死锁的必要条件：

• 互斥条件：该资源任意一个时刻只由一个线程占用。
• 请求与保持条件：一个线程因请求资源而阻塞时，同时对已获得的资源保持不放。
• 不剥夺条件：线程保持的资源需要等待使用完才能释放，不能被其他线程剥夺。
• 循环等待条件：若干线程之间形成一种头尾相接的循环等待资源关系。

如何预防死锁？破坏死锁的产生的必要条件即可：

• 破坏请求与保持条件：一次性申请所有的资源。
• 破坏不剥夺条件：占用部分资源的线程因请求资源时阻塞时，主动释放占用的资源。
• 破坏循环等待条件：按某一顺序申请资源，释放资源则反序释放。

如何避免死锁？

? ? ? ? 使用银行家算法对资源分配进行计算评估，使其进入安全状态。

17、谈谈ConcurrentHashMap?（????）

• 底层数据结构：
  • JDK1.7及之前之前采用 分段数组(segment) + 链表实现。
  • JDK1.8开始底层的数据结构和JDK1.8HashMap一样，采用数组+链表/红黑树实现。
• 加锁方式：
  • JDK1.7采用Segment分段锁，底层使用的是ReentrantLock。
  • JDK1.8放弃了Segment分段锁的设计，采用?CAS + synchronized?保证线程安全，锁粒度更细。CAS控制数组节点的添加，synchronized只锁定当前链表或红黑二叉树的首节点，只要hash不冲突，就不会产生并发安全问题。

jdk1.7：

jdk1.8：

18、Java中怎么保证多线程的执行安全？（???）

????????满足Java并发编程的三大特性：

• 原子性：一段程序执行是不可分割的，要么全部执行成功，要么全部失败。
  • 可以使用synchronized和lock保证程序的原子性。
• 可见性：一个线程对共享变量的修改对另一个线程可见。
  • 可以使用volatile(推荐)保证可见性，synchronized、Lock也可以。
• 有序性：在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
  • 可以通过volatile关键字来保证一定的“有序性”，synchronized和Lock也可以。

---

三、线程池

19、什么是线程池？为什么要用线程池？

????????线程池就是管理一系列线程的资源池。当有任务要处理时，直接从线程池中获取线程来处理，处理完之后线程并不会立即被销毁，而是等待下一个任务。池化技术的好处：

• 降低资源消耗。重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 提高响应速度。当有任务时，可以不需要等待线程的创建就能立即执行。

20、线程池的核心参数（????）

线程池有七个参数：

• corePoolSize：核心线程数目
• maximumPoolSize：最大线程数目 = 核心线程 + 临时线程的最大数目
• workQueue：当没有空闲核心线程时，新来任务会加入到此队列排队，当队列满时会创建临时线程执行任务
• keepAliveTime：临时线程的生存时间，若生存时间内没有新任务，此线程资源会释放
• unit：临时线程生存时间的单位
• threadFactory：线程工厂，可以定制线程对象的创建，如设置线程名字、是否是守护线程等
• handler：拒绝策略 - 当所有线程都在繁忙，队列也放满时，会触发拒绝策略
  • 1.AbortPolicy：直接抛出异常，默认策略；
  • 2.CallerRunsPolicy：用调用者所在的线程来执行任务；
  • 3.DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
  • 4.DiscardPolicy：直接丢弃任务；

工作流程图：

21、线程池中有哪些常见的阻塞队列（???）

• ArrayBlockingQueue：基于数组结构的有界阻塞队列，FIFO。
• LinkedBlockingQueue：基于链表结构的有界阻塞队列，FIFO。
• DelayedWorkQueue ：是一个优先级队列，它可以保证每次出队的任务都是当前队列中执行时间最靠前的。
• SynchronousQueue：不存储元素的阻塞队列，每个插入操作都必须等待一个移出操作。

ArrayBlockingQueue的LinkedBlockingQueue区别：

• LinkedBlockingQueue默认无界，支持有界；ArrayBlockingQueue强制有界。
• LinkedBlockingQueue底层是单向链表实现；ArrayBlockingQueue基于数组实现。
• LinkedBlockingQueue头尾各一把锁，效率较高；ArrayBlockingQueue只有一把锁。

22、如何确定核心线程数？（???）

• CPU密集型任务：这类任务消耗的主要是 CPU 资源，可以将线程核心数设置为 N（CPU 核心数）+1。
  • 多出来的一个核心线程是为了防止各种原因导致任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的线程可以充分利用 CPU 的空闲时间。

• I/O密集型任务：这类任务系统会将大部分时间用在I/O交互上，这段时间CPU是空闲的，可以交给其他线程使用，因此可以多配置一些线程，常用的值为2N（CPU核心数）。

23、如何创建线程池？线程池有哪些种类？（???）

• 方式一：使用ThreadPoolExecutor构造函数来创建。

• 方式二：使用Executors工具类来创建。
  • newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
  • newSingleThreadExecutor：创建一个单线程的线程池，若多余的任务被提交到该线程池，其会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
  • newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
  • newScheduledThreadPool：可执行延迟任务的线程池，支持定时及周期性任务执行。

?24、为什么不推荐使用内置线程池（Executors）？（???）

参考阿里巴巴开发手册：

25、Future 类有什么用？

????????Future 类是异步思想的典型运用，主要用在一些需要执行耗时任务的场景。具体来说：当我们执行某一耗时的任务时，可以将这个耗时任务交给一个子线程去异步执行，同时我们可以执行其他任务，不用傻傻等待耗时任务执行完成。等我们的事情干完后，我们再通过 Future 类获取到耗时任务的执行结果。以此提高程序的执行效率。

????????在 Java 中，Future 类只是一个泛型接口，内部实现了以下四种功能：

• 取消任务；
• 判断任务是否被取消;
• 判断任务是否已经执行完成;
• 获取任务执行结果。

// V 代表了Future执行的任务返回值的类型
public interface Future<V> {
    // 取消任务执行
    // 成功取消返回 true，否则返回 false
    boolean cancel(boolean mayInterruptIfRunning);
    // 判断任务是否被取消
    boolean isCancelled();
    // 判断任务是否已经执行完成
    boolean isDone();
    // 获取任务执行结果
    V get() throws InterruptedException, ExecutionException;
    // 指定时间内没有返回计算结果就抛出 TimeOutException 异常
    V get(long timeout, TimeUnit unit)

        throws InterruptedException, ExecutionException, TimeoutExceptio

}