Java多线程的面试题欢迎关注WX公众号：“程序猿补课班”，分享Java相关技术知识，学习经验，面试经验等。小伙伴快来补

欢迎关注WX公众号：“程序猿补课班”，分享Java相关技术知识，学习经验，面试经验等。小伙伴快来补课吧！

1.sleep()，wait()的区别？

sleep是线程类（Thread）的方法，
wait是Object类的方法，
sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。
wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，
只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。

2.Java 中怎样唤醒一个阻塞的线程？

如果线程是因为调用了 wait()、sleep()或者 join()方法而导致的阻塞，可以
中断线程，并且通过抛出 InterruptedException 来唤醒它；
如果线程遇到了IO 阻塞，无能为力，因为 IO 是操作系统实现的，Java 代码并没有办法直接
接触到操作系统

3.现在有 T1、T2、T3 三个线程，你怎样保证 T2 在 T1 执行完后执行，T3 在 T2 执行完后执行？

利用Thread类的join 方法

4.join方法传参和不传参的区别？

join方法中如果传入参数，则表示：如果A线程中调用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并行执行。

join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。

5.join方法实现原理

join方法是通过调用线程的wait方法来达到同步的目的的。例如A线程中调用了B线程的join方法，则相当于在A线程中调用了B线程的wait方法，
当B线程执行完（或者到达等待时间），B线程会自动调用自身的notifyAll方法唤醒A线程，从而达到同步的目的。

由join方法源码可以看到：
1、如果join方法传参为0的话，则会调用isAlive()方法，一直检测线程是否存活（执行完毕）,如果存活就调用wait方法，一直阻塞。
2、如果参数为负数，则直接报错：“timeout value is negative”
3、如果参数大于0，则while里面一直判断线程是否存活，存活的话就一直判断当前线程执行的时间并与计算还需要等待多久时间，最后如果等待时间小于等于0就跳出循环，否则就继续wait。

public final synchronized void join(long millis) throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
 
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

6.AQS 框架是怎么回事儿？

AQS 全称为 AbstractQueuedSychronizer，翻译过来应该是抽象队列同步器。

AQS 在内部定义了一个 volatile int state 变量，表示同步状态：当线程调用 lock 方法时，如果 state=0，说明没有任何线程占有共享资源的锁，可以获得锁并将 state=1；如果 state=1，则说明有线程目前正在使用共享变量，其他线程必须加入同步队列进行等待。
AQS 通过 Node 内部类构成的一个双向链表结构的同步队列，来完成线程获取锁的排队工作，当有线程获取锁失败后，就被添加到队列末尾。Node 类是对要访问同步代码的线程的封装，包含了线程本身及其状态叫waitStatus（有五种不同取值，分别表示是否被阻塞，是否等待唤醒，是否已经被取消等），每个 Node 结点关联其 prev 结点和 next 结点，方便线程释放锁后快速唤醒下一个在等待的线程，是一个 FIFO 的过程。

Node 类有两个常量， SHARED 和 EXCLUSIVE，分别代表共享模式和独占模式。所谓共享模式是一个锁允许多条线程同时操作（信号量Semaphore 就是基于 AQS 的共享模式实现的），独占模式是同一个时间段只能有一个线程对共享资源进行操作，多余的请求线程需要排队等待（如 ReentranLock）。

AQS 通过内部类 ConditionObject 构建等待队列（可有多个），当Condition 调用 wait() 方法后，线程将会加入等待队列中，而当Condition 调用 signal() 方法后，线程将从等待队列转移动同步队列中进行锁竞争。
AQS 和 Condition 各自维护了不同的队列，在使用 Lock 和Condition 的时候，其实就是两个队列的互相移动。

7. Synchronized 和 ReentrantLock 的区别？

主要相同点：Lock 能完成 synchronized 所实现的所有功能。
主要不同点：Lock 有比 synchronized 更精确的线程语义和更好的性能。
synchronized 会自动释放锁，而 Lock 一定要求程序员手工释放，并且必须在 finally 从句中释放。Lock 还有更强大的功能，例如，它的 tryLock 方法可以非阻塞方式去拿锁。

8.创建线程池的几个核心构造参数？

corePoolSize：线程池的核心线程数。
maximumPoolSize：线程池允许的最大线程数。
keepAliveTime：超过核心线程数时闲置线程的存活时间。
workQueue：任务执行前保存任务的队列，保存由 execute 方法提交的 Runnable 任务。

9.线程池中的线程是怎么创建的？是一开始就随着线程池的启动创建好的吗？

显然不是的。线程池默认初始化后不启动 Worker，等待有请求时才启动。每当我们调用 execute() 方法添加一个任务时，线程池会做如下判断：如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；如果这时候队列满了，而且正在运行的线程数量小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；如果队列满了，而且正在运行的线程数量大于或等于maximumPoolSize ，那么线程池会抛出异常RejectExecutionException。当一个线程完成任务时，它会从队列中取下一个任务来执行。当一个线程无事可做，超过一定的时间（ keepAliveTime）时，线程池会判断。如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

10.Java 中默认实现好的线程池又有哪些呢？

SingleThreadExecutor 线程池这个线程池只有一个核心线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
FixedThreadPool 线程池

FixedThreadPool 是固定大小的线程池，只有核心线程。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

FixedThreadPool 多数针对一些很稳定很固定的正规并发线程，多用于服务器。

CachedThreadPool 线程池

CachedThreadPool 是无界线程池，如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（ 60 秒不执行任务）线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。线程池大小完全依赖于操作系统（或者说 JVM）能够创建的最大线程大小。SynchronousQueue 是一个是缓冲区为 1 的阻塞队列。

缓存型池子通常用于执行一些生存期很短的异步型任务，因此在一些面向连接的 daemon 型 SERVER 中用得不多。但对于生存期短的异步任务，它是 Executor 的首选。

ScheduledThreadPool 线程池ScheduledThreadPool：核心线程池固定，大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。创建一个周期性执行任务的线程池。如果闲置，非核心线程池会在 DEFAULT_KEEPALIVEMILLIS 时间内回收。

11.如何在 Java 线程池中提交线程？

线程池最常用的提交任务的方法有两种：

execute()：ExecutorService.execute方法接收一个Runable 实例，它用来执行一个任务：
submit()：ExecutorService.submit() 方法返回的是Future对象。可以用 isDone() 来查询 Future 是否已经完成，当任务完成时，它具有一个结果，可以调用 get() 来获取结果。也可以不用 isDone() 进行检查就直接调用 get()，在这种情况下，get() 将阻塞，直至结果准备就绪。

12.请谈谈 volatile 有什么特点，为什么它能保证变量对所有线程的可见性？

关键字 volatile 是 Java 虚拟机提供的最轻量级的同步机制。当一个变量被定义成 volatile 之后，具备两种特性：

保证此变量对所有线程的可见性。当一条线程修改了这个变量的值，新值对于其他线程是可以立即得知的。而普通变量做不到这一点。
禁止指令重排序优化。普通变量仅仅能保证在该方法执行过程中，得到正确结果，但是不保证程序代码的执行顺序。

既然 volatile 能够保证线程间的变量可见性，是不是就意味着基于 volatile 变量的运算就是并发安全的？

显然不是的。基于 volatile 变量的运算在并发下不一定是安全的。volatile 变量在各个线程的工作内存，不存在一致性问题（各个线程的工作内存中 volatile 变量，每次使用前都要刷新到主内存）。但是 Java 里面的运算并非原子操作，导致 volatile 变量的运算在并发下一样是不安全的。

13.请谈谈 ThreadLocal 是怎么解决并发安全的？

ThreadLocal 这是 Java 提供的一种保存线程私有信息的机制，因为其在整个线程生命周期内有效，所以可以方便地在一个线程关联的不同业务模块之间传递信息，比如事务 ID、 Cookie 等上下文相关信息。ThreadLocal 为每一个线程维护变量的副本，把共享数据的可见范围限制在同一个线程之内，其实现原理是，在 ThreadLocal 类中有一个Map，用于存储每一个线程的变量的副本。

14.请说出你所知道的线程同步的方法。

wait()：使一个线程处于等待状态，并且释放所持有的对象的 lock。
sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException 异常。 notify()：唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由 JVM 确定唤醒哪个线程，而且不是按优先级。 notityAll()：唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

15.ReadWriteLock 是什么？

首先明确一下，不是说 ReentrantLock 不好，只是 ReentrantLock 某些时候有局限。如果使用 ReentrantLock，可能本身是为了防止线程 A 在写数据、线程 B 在读数据造成的数据不一致，但这样，如果线程 C 在读数据、线程 D也在读数据，读数据是不会改变数据的，没有必要加锁，但是还是加锁了，降低了程序的性能。因为这个，才诞生了读写锁 ReadWriteLock。ReadWriteLock 是一个读写锁接口，ReentrantReadWriteLock 是 ReadWriteLock 接口的一个具体实现，实现了读写的分离，读锁是共享的，写锁是独占的，读和读之间不会互斥，读和写、写和读、写和写之间才会互斥，提升了读写的性能。

16.什么是 CAS

CAS，全称为 Compare and Swap，即比较-替换。假设有三个操作数：内
存值 V、旧的预期值 A、要修改的值 B，当且仅当预期值 A 和内存值 V 相同
时，才会将内存值修改为 B 并返回 true，否则什么都不做并返回 false。当
然 CAS 一定要 volatile 变量配合，这样才能保证每次拿到的变量是主内存中
最新的那个值，否则旧的预期值 A 对某条线程来说，永远是一个不会变的值 A，只要某次 CAS 操作失败，永远都不可能成功。

如有错漏之处,敬请指正