多线程面试题

如何预防死锁？

首先需要将死锁发生的四个必要条件讲出来:

• 互斥条件 同一时间只能有一个线程获取资源（资源有限）
• 循环等待条件 多个线程互相等待对方释放资源（a占有b想要的资源，b占有a想要的资源，互相不释放）
• 不可剥夺条件 一个线程已经占有的资源，在释放之前不会被其它线程抢占
• 请求和保持条件 线程等待过程中不会释放已占有的资源
  死锁预防，那么就是需要破坏这四个必要条件（银行家算法）
• 由于资源互斥是资源使用的固有特性，无法改变，我们不讨论
• 破坏不可剥夺条件
  一个进程不能获得所需要的全部资源时便处于等待状态，等待期间他占有的资源将被隐式的释放重新加入到系统的资源列表中，可以被其他的进程使用，而等待的进程只有重新获得自己原有的资源以及新申请的资源才可以重新启动，执行
• 破坏请求与保持条件
  第一种方法静态分配即每个进程在开始执行时就申请他所需要的全部资源,
  第二种是动态分配即每个进程在申请所需要的资源时他本身不占用系统资源
• 破坏循环等待条件
  采用资源有序分配其基本思想是将系统中的所有资源顺序编号，将紧缺的，稀少的采用较大的编号，在申请资源时必须按照编号的顺序进行，一个进程只有获得较小编号的进程才能申请较大编号的进程。

多线程有哪几种创建方式？

• 实现Runnable，Runnable规定的方法是run()，无返回值，无法抛出异常
• 实现Callable，Callable规定的方法是call()，任务执行后有返回值，可以抛出异常
• 继承Thread类创建多线程：继承java.lang.Thread类，重写Thread类的run()方法，在run()方法中实现运行在线程上的代码，调用start()方法开启线程。
  Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线程，并执行 run()方法
• futureTask
  通过线程池创建线程. 线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建，不需要的时候销毁，是非常浪费资源的。那么我们就可以使用缓存的策略，也就是使用线程池。

描述一下线程安全活跃态问题，竞态条件？

线程安全的活跃性问题可以分为 死锁、活锁、饥饿

• 活锁 就是有时线程虽然没有发生阻塞，但是仍然会存在执行不下去的情况，活锁不会阻塞线程，线程会一直重复执行某个相同的操作，并且一直失败重试
  我们开发中使用的异步消息队列就有可能造成活锁的问题，在消息队列的消费端如果没有正确的ack消息，并且执行过程中报错了，就会再次放回消息头，然后再拿出来执行，一直循环往复的失败。这个问题除了正确的ack之外，往往是通过将失败的消息放入到延时队列中，等到一定的延时再进行重试来解决。
  解决活锁的方案很简单，尝试等待一个随机的时间就可以，会按时间轮去重试
• 饥饿 就是 线程因无法访问所需资源而无法执行下去的情况，（例如读写锁,有无数读线程去读 读优先那么写锁就是饥饿)
  饥饿 分为两种情况：
  一种是线程在临界区做了无限循环或无限制等待资源的操作，让其他的线程一直不能拿到锁进入临界区，对其他线程来说，就进入了饥饿状态
  另一种是因为线程优先级不合理的分配，导致部分线程始终无法获取到CPU资源而一直无法执行
  解决饥饿的问题有几种方案:
  保证资源充足，很多场景下，资源的稀缺性无法解决
  公平分配资源，在并发编程里使用公平锁，例如FIFO策略，线程等待是有顺序的，排在等待队列前面的线程会优先获得资源
  避免持有锁的线程长时间执行，很多场景下，持有锁的线程的执行时间也很难缩短
• 死锁

线程在对同一把锁进行竞争的时候，未抢占到锁的线程会等待持有锁的线程释放锁后继续抢占，如果两个或两个以上的线程互相持有对方将要抢占的锁，互相等待对方先行释放锁就会进入到一个循环等待的过程，这个过程就叫做死锁
线程安全的竞态条件问题
同一个程序多线程访问同一个资源，如果对资源的访问顺序敏感，就称存在竞态条件，代码区成为临界区。 大多数并发错误一样，竞态条件不总是会产生问题，还需要不恰当的执行时序
常见的竞态条件为
先检测后执行执行依赖于检测的结果，而检测结果依赖于多个线程的执行时序，而多个线程的执行时序通常情况下是不固定不可判断的，从而导致执行结果出现各种问题，见一种可能 的解决办法就是：在一个线程修改访问一个状态时，要防止其他线程访问修改，也就是加锁机制，保证原子性
延迟初始化（典型为单例）

Java中的wait和sleep的区别与联系？

• 所属类

:首先，这两个方法来自不同的类分别是Thread和Object ，wait是Object的方法， sleep是Thread的方法
sleep方法属于Thread类中方法，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态，因为线程调度机制恢复线程的运行也需要时间。一个线程对象调用了sleep方法之后，并不会释放他所持有的所有对象锁，所以也就不会影响其他进程对象的运行。但在sleep的过程中过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块(可能还有finally语句块)以及以后的代码

• 作用范围

sleep方法没有释放锁，只是休眠，而wait释放了锁，使得其他线程可以使用同步控制块或方法

• 使用范围

: wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

• 异常范围

： sleep必须显示的捕获InterruptedException异常，而wait，notify和notifyAll不需要强制捕获InterruptedException异常

描述一下进程与线程区别？

• 进程（Process）

是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。总结: 进程是指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位

• 线程

操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。总结: 系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位

• 协程

协程是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

描述一下Java线程的生命周期？

大致包括5个阶段

• 新建

就是刚使用new方法，new出来的线程；

• 就绪

就是调用的线程的start()方法后，这时候线程处于等待CPU分配资源阶段，谁先抢的CPU资源，谁开始执行;

• 运行

当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能;

• 阻塞

在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态，比如sleep()、wait()之后线程就处于了阻塞状态，这个时候需要其他机制将处于阻塞状态的线程唤醒，比如调用notify或者notifyAll()方法。唤醒的线程不会立刻执行run方法，它们要再次等待CPU分配资源进入运行状态;

• 销毁

如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束，那么线程就要被销毁，释放资源

按JDK的源码分析来看，Thread的状态分为：
NEW： 尚未启动的线程的线程状态
RUNNABLE： 处于可运行状态的线程正在Java虚拟机中执行，但它可能正在等待来自操作系统（例如处理器）的其他资源
BLOCKED： 线程的线程状态被阻塞，等待监视器锁定。处于阻塞状态的线程正在等待监视器锁定以输入同步的块方法或在调用后重新输入同步的块方法，通过 Object#wait()进入阻塞
WAITING：处于等待状态的线程正在等待另一个线程执行特定操作：例如: 在对象上调用了Object.wait（）的线程正在等待另一个线程调用Object.notify（） 或者 Object.notifyAll(), 调用了 Thread.join（）的线程正在等待指定的线程终止
TIMED_WAITING ： 具有指定等待时间的等待线程的线程状态。由于以指定的正等待时间调用以下方法之一，因此线程处于定时等待状态：
Thread.sleep（long）
Object#wait(long)
Thread.join（long）
LockSupport.parkNanos（long…）
LockSupport.parkUntil（long…）
TERMINATED: 终止线程的线程状态。线程已完成执行

程序开多少线程合适？

这里需要区别下应用是什么样的程序：
CPU 密集型程序， 一个完整请求，I/O操作可以在很短时间内完成， CPU还有很多运算要处理，也就是说 CPU 计算的比例占很大一部分，线程等待时间接近0
单核CPU： 单核CPU处理CPU密集型程序，这种情况并不太适合使用多线程，
多核 ： 如果是多核CPU 处理 CPU 密集型程序，我们完全可以最大化的利用 CPU核心数，应用并发编程来提高效率。CPU 密集型程序的最佳线程数就是：因此对于CPU 密集型来说，理论上 线程数量 = CPU 核数（逻辑），但是实际上，数量一般会设置为 CPU 核数（逻辑）+ 1（经验值）
计算(CPU)密集型的线程恰好在某时因为发生一个页错误或者因其他原因而暂停，刚好有一个“额外”的线程，可以确保在这种情况下CPU周期不会中断工作
I/O 密集型程序，与 CPU 密集型程序相对，一个完整请求，CPU运算操作完成之后还有很多 I/O 操作要做，也就是说 I/O 操作占比很大部分，等待时间较长，线程等待时间所占比例越高，需要越多线程；线程CPU时间所占比例越高，需要越少线程
I/O 密集型程序的最佳线程数就是： 最佳线程数 = CPU核心数 (1/CPU利用率) = CPU核心数 (1 + (I/O耗时/CPU耗时))
如果几乎全是 I/O耗时，那么CPU耗时就无限趋近于0，所以纯理论你就可以说是2N（N=CPU核数），当然也有说 2N + 1的，1应该是backup
一般我们说 2N + 1 就即可