多线程与并发编程面试专题

csdn

多线程与并发编程面试专题

线程的基础概念
- 基础概念
- 线程的创建
- 线程的状态
- 线程的终止方式
- start 与 run 区别
- 线程的常用方法
锁
- 锁的分类
- 深入synchronized
- 深入ReentrantLock
- 死锁问题
阻塞队列
线程池

线程的基础概念

基础概念

进程与线程
- 进程：指运行中的程序。比如我们使用钉钉，浏览器，需要启动这个程序，操作系统会给这个程序分配一定的资源（占用内存资源）。
- 线程：CPU调度的基本单位，每个线程执行的都是某一个进程的代码的某个片段。
多线程
- 单个进程中同时运行多个线程。
- 多线程的不低是为了提高CPU的利用率。可以通过避免一些网络IO或者磁盘IO等需要等待的操作，让CPU去调度其他线程。这样可以大幅度的提升程序的效率，提高用户的体验。
- 多线程的局限
  - 如果线程数量特别多，CPU在切换线程上下文时，会额外造成很大的消耗。
  - 任务的拆分需要依赖业务场景，有一些异构化的任务，很难对任务拆分，还有很多业务并不是多线程处理更好。
  - 线程安全问题：虽然多线程带来了一定的性能提升，但是再做一些操作时，多线程如果操作临界资源，可能会发生一些数据不一致的安全问题，甚至涉及到锁操作时，会造成死锁问题。
串行、并行、并发
- 串行：任务按严格顺序执行，前一个任务完成后再开始下一个。
- 并行：多个任务真正同时执行，依赖多核CPU或多处理器。
- 并发：任务交替执行（单核）或同时执行（多核），通过调度模拟“同时性”。
同步异步、阻塞非阻塞
- 同步：任务按顺序执行，前一个任务未完成时，后续任务必须等待。
- 异步：任务发起后，不等待其完成，继续执行后续操作，通过回调/通知获取结果。
- 阻塞：线程在等待某个操作（如I/O、锁）完成时，暂停执行，交出CPU控制权。
- 非阻塞：线程在等待操作完成时继续执行其他任务，通过轮询或回调检查结果。
- 同步阻塞：单线程调用阻塞式I/O（如传统文件读取）
- 同步非阻塞：循环调用非阻塞I/O，不断检查数据是否就绪。
- 异步阻塞：错误设计（如在异步操作中使用阻塞调用）。
- 异步非阻塞：异步I/O（如Node.js的fs.readFile），发起请求后继续执行其他任务，通过回调或Promise处理结果。

线程的创建

继承Thread类重写run方法

public class MiTest {
	public static void main(String[] args) {
		MyJob t1 = new MyJob();
		t1.start();
		for (int i = 0; i < 100; i++) {
		System.out.println("main:" + i);
		}
	}
}
class MyJob extends Thread{
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("MyJob:" + i);
		}
	}
}

实现Runnable接口重写run方法

public class MiTest {
	public static void main(String[] args) {
		MyRunnable myRunnable = new MyRunnable();
		Thread t1 = new Thread(myRunnable);
		t1.start();
		for (int i = 0; i < 1000; i++) {
			System.out.println("main:" + i);
		}
	}
}
class MyRunnable implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("MyRunnable:" + i);
		}
	}
}

匿名内部类方式

Thread t1 = new Thread(new Runnable() {
	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("匿名内部类:" + i);
		}
	}
});

lambda方式

Thread t2 = new Thread(() -> {
	for (int i = 0; i < 100; i++) {
		System.out.println("lambda:" + i);
	}
});

实现Callable 重写call方法，配合FutureTask
Callable一般用于有返回结果的非阻塞的执行方法，同步非阻塞。

public class MiTest {
	public static void main(String[] args) throws ExecutionException, InterruptedException {
	//1. 创建MyCallable
	MyCallable myCallable = new MyCallable();
	//2. 创建FutureTask，传入Callable
	FutureTask futureTask = new FutureTask(myCallable);
	//3. 创建Thread线程
	Thread t1 = new Thread(futureTask);
	//4. 启动线程
	t1.start();
	//5. 做一些操作
	//6. 要结果
	Object count = futureTask.get();
	System.out.println("总和为：" + count);
	}
}
class MyCallable implements Callable{
	@Override
	public Object call() throws Exception {
		int count = 0;
		for (int i = 0; i < 100; i++) {
			count += i;
		}
		return count;
	}
}

基于线程池构建线程

// 创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while(true) {
	threadPool.execute(new Runnable() { // 提交多个线程任务，并执行
		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName() + " is running ..");
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	});
}

线程的状态

新建状态（NEW）：当程序使用 new 关键字创建了一个线程之后，该线程就处于新建状态，此时仅由 JVM 为其分配内存，并初始化其成员变量的值。
就绪状态（RUNNABLE）:当线程对象调用了 start()方法之后，该线程处于就绪状态。 Java 虚拟机会为其创建方法调用栈和程序计数器，等待调度运行。
运行状态（RUNNING）：就绪状态的线程获得了 CPU，开始执行 run()方法的线程执行体，则该线程处于运行状态。
阻塞状态（BLOCKED）：线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice，暂时停止运行。直到线程进入可运(runnable)状态，才有机会再次获得 cpu timeslice 转到运行(running)状态。
阻塞的情况分三种：
- 等待阻塞（o.wait->等待对列）：运行(running)的线程执行 o.wait()方法， JVM 会把该线程放入等待队列(waitting queue)中。
- 同步阻塞(lock->锁池)：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池(lock pool)中。
- 其他阻塞(sleep/join)：运行(running)的线程执行Thread.sleep(long ms)或 t.join()方法，或者发出了 I/O 请求时，JVM 会把该线程置为阻塞状态。当 sleep()状态超时、 join()等待线程终止或者超时、或者 I/O处理完毕时，线程重新转入可运行(runnable)状态。
等待状态（WATING）：调用wait方法就会处于WAITING状态，需要被手动唤醒。
时间等待状态（TIMED_WATING）：调用sleep方法或者join方法，会被自动唤醒，无需手动唤醒。
结束状态（TERMINATED）：线程会以下面三种方式结束，结束后就是死亡状态。
- run()或 call()方法执行完成，线程正常结束。异常结束。
- 线程抛出一个未捕获的 Exception 或 Error。调用 stop。
- 直接调用该线程的 stop()方法来结束该线程—该方法通常容易导致死锁，不推荐使用。

线程的终止方式

正常运行结束：程序运行结束，线程自动结束。
使用volatile修饰的共享变量（很少会用）：通过修改共享变量在破坏死循环，让线程退出循环，结束run方法。
Interrupt 方法结束线程：
- 线程处于阻塞状态：如使用了 sleep,同步锁的 wait,socket 中的 receiver,accept 等方法时，会使线程处于阻塞状态。当调用线程的interrupt()方法时，会抛出 InterruptException 异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后 break 跳出循环状态，从而让我们有机会结束这个线程的执行。通常很多人认为只要调用 interrupt 方法线程就会结束，实际上是错的，一定要先捕获InterruptedException 异常之后通过 break 来跳出循环，才能正常结束 run 方法。
- 线程未处于阻塞状态：使用 isInterrupted()判断线程的中断标志来退出循环。当使用interrupt()方法时，中断标志就会置 true，和使用自定义的标志来控制循环是一样的道理。
stop 方法终止线程（线程不安全）：强制让线程结束。

start 与 run 区别

start（）方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码。
通过调用 Thread 类的 start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。
方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了运行状态，开始运行 run 函数当中的代码。 Run 方法运行
结束，此线程终止。然后 CPU 再调度其它线程。

线程的常用方法

notify()和notifyAll()有什么区别
- 唤醒的线程数量
  - notify()：随机唤醒 一个 正在该对象上调用 wait() 的线程（无法指定具体唤醒哪个线程）。
  - notifyAll()：唤醒 所有 正在该对象上调用 wait() 的线程。
- 适用场景
  - notify()：当所有等待线程的 逻辑等价（即任何一个线程被唤醒都能完成后续任务）时，使用 notify() 更高效。
  - notifyAll()：当等待线程的 条件不同（需要确保所有等待线程都有机会重新检查条件）时，使用 notifyAll() 更安全。
- 潜在风险
  - notify() ：如果多个线程等待的条件不同，可能唤醒错误的线程（例如生产者唤醒了另一个生产者），导致某些线程永远无法被唤醒（线程饥饿或死锁）。
  - notifyAll()：唤醒所有线程会增加锁竞争，可能降低性能（但在现代 JVM 中影响较小）。
sleep()和wait() 有什么区别
- 所属类与调用对象
  - sleep()
    - 属于 Thread 类的静态方法。
    - 直接通过 Thread.sleep(ms) 调用，作用于当前线程。
  - wait()
    - 属于 Object 类的实例方法。
    - 必须在同步块（synchronized）中调用，作用于某个对象（如 obj.wait()）。
- 锁的行为
  - sleep()
    - 不释放锁：线程休眠期间，仍然持有对象的锁（如果已获得）。
    - 其他线程无法进入该对象的同步块。
  - wait()
    - 释放锁：调用后线程会释放对象的锁，允许其他线程获取锁并执行同步代码。
    - 线程进入等待队列，直到被 notify()/notifyAll() 唤醒或超时。
- 使用场景
  - sleep()
    - 单纯让线程暂停执行一段时间，不涉及线程间协作。
    - 示例：模拟耗时操作，定时任务间隔。
  - wait()
    - 用于线程间通信，需结合 notify()/notifyAll() 实现条件等待。
    - 示例：生产者-消费者模型中，消费者等待队列有数据。
- 唤醒机制
  - sleep()：休眠结束后自动恢复，无需外部唤醒（除非被 interrupt() 中断）。
  - wait()：必须通过其他线程调用 notify()/notifyAll() 唤醒，或等待超时（若指定了超时时间）。
异常处理
- 共同点：两者都可能抛出 InterruptedException（当线程在等待/休眠期间被中断时）。
- 区别
  - wait() 必须在同步块中调用，否则抛IllegalMonitorStateException。
  - sleep() 无此限制。
线程状态
- sleep()：线程进入 TIMED_WAITING 状态（若指定时间）或 WAITING（若时间无限，但实际 sleep() 必须指定时间）。
- wait()：线程进入 WAITING 状态（无超时）或 TIMED_WAITING 状态（有超时）。

Java中interrupted 和 isInterrupted方法的区别

方法定义与作用对象

方法	类型	作用对象	描述
Thread.interrupted()	静态方法	当前执行线程	检查并清除当前线程的中断状态。
thread.isInterrupted()	实例方法	调用该方法的线程对象	仅检查线程的中断状态，不修改状态。

Thread类中的yield方法有什么作用
- Thread.yield() 是一个用于线程调度的静态方法，其主要作用是提示当前线程让出CPU资源，允许其他线程（尤其是优先级相同或更高的线程）有机会执行。

锁

锁的分类

悲观锁
乐观锁
可重入锁
不可重入锁
公平锁
非公平锁
互斥锁
共享锁

深入synchronized

深入ReentrantLock

死锁问题

死锁产生的必要条件
- 互斥（Mutual Exclusion）：资源一次只能被一个线程占用。
- 请求与保持（Hold and Wait）：线程持有至少一个资源，同时请求其他线程持有的资源。
- 不可剥夺（No Preemption）：资源只能由持有它的线程主动释放，不能被强制剥夺。
- 循环等待（Circular Wait）：多个线程形成环形等待链，每个线程都在等待下一个线程释放资源。
常见死锁场景
- 场景1：嵌套锁顺序不一致
```
// 线程1
synchronized (lockA) {
    synchronized (lockB) { ... }
}

// 线程2
synchronized (lockB) {
    synchronized (lockA) { ... } // 可能导致死锁
}
```
- 场景2：生产者-消费者模型中的资源竞争
  多个线程在共享队列中同时获取插入和删除的锁。
- 场景3：数据库事务中的行级锁
  多个事务以不同顺序更新相同的数据行。

如何检测死锁

JVM工具
- 使用 jstack <pid> 导出线程栈，查找 Found one Java-level deadlock。
- 使用 jconsole 或 VisualVM 查看线程状态。

代码检测

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] threadIds = bean.findDeadlockedThreads();
if (threadIds != null) {
    System.out.println("检测到死锁！");
}

死锁预防与解决

方法1：统一加锁顺序

核心思想：确保所有线程按相同的顺序请求资源。

示例：在转账场景中，按账户哈希值排序锁。

void transfer(Account from, Account to, int amount) {
    Account first = from.hashCode() < to.hashCode() ? from : to;
    Account second = from.hashCode() < to.hashCode() ? to : from;
    
    synchronized (first) {
        synchronized (second) {
            // 转账逻辑
        }
    }
}

方法2：避免嵌套锁
- 尽量减少锁的作用域，使用无锁设计（如CAS操作）或线程安全容器（如ConcurrentHashMap）。

方法3：设置超时等待

使用 tryLock 替代 synchronized，设定超时时间。

Lock lockA = new ReentrantLock();
Lock lockB = new ReentrantLock();
if (lockA.tryLock(1, TimeUnit.SECONDS)) {
    try {
        if (lockB.tryLock(1, TimeUnit.SECONDS)) {
            try { ... } finally { lockB.unlock(); }
        }
    } finally { lockA.unlock(); }
}

方法4：破坏不可剥夺条件
- 允许系统强制回收资源（需谨慎，可能导致数据不一致）。
方法5：使用线程池隔离
- 将不同任务分配到独立的线程池，避免资源竞争。

阻塞队列

阻塞队列原理
- 当队列中没有数据的情况下，消费者端的所有线程都会被自动阻塞（挂起），直到有数据放入队列。
- 当队列中填满数据的情况下，生产者端的所有线程都会被自动阻塞（挂起），直到队列中有空的位置，线程被自动唤醒。
阻塞队列的主要方法
阻塞队列分类
- ArrayBlockingQueue ：由数组结构组成的有界阻塞队列。
- LinkedBlockingQueue ：由链表结构组成的有界阻塞队列。
- PriorityBlockingQueue ：支持优先级排序的无界阻塞队列。
- DelayQueue：使用优先级队列实现的无界阻塞队列。
- SynchronousQueue：不存储元素的阻塞队列。
- LinkedTransferQueue：由链表结构组成的无界阻塞队列。
- LinkedBlockingDeque：由链表结构组成的双向阻塞队列

线程池

线程池分类
- newCachedThreadPool：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。
- newFixedThreadPool：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线。
- newScheduledThreadPool：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
- newSingleThreadExecutor：Executors.newSingleThreadExecutor()返回一个线程池（这个线程池只有一个线程） ,这个线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去。
线程池配置属性
- 核心线程数（corePoolSize）
  - 作用：线程池中始终保持的最小线程数，即使这些线程处于空闲状态。
  - 注意事项：
    - 默认情况下，核心线程不会因空闲而被回收（除非配置了allowCoreThreadTimeOut）。
    - 适用于处理常规任务负载。
- 最大线程数（maximumPoolSize）
  - 作用：线程池允许创建的最大线程数量。当工作队列已满且当前线程数小于最大线程数时，会创建新线程处理任务。
  - 注意事项：
    - 需根据系统资源（如CPU核数、内存）和任务类型（CPU密集型或IO密集型）合理设置。
    - 若设置为与corePoolSize相同，则线程池退化为固定大小线程池。
- 空闲线程存活时间（keepAliveTime）
  - 作用：非核心线程（超出corePoolSize的线程）在空闲状态下的存活时间。超过该时间后，线程会被终止回收。
  - 单位：通常与TimeUnit配合使用（如秒、毫秒）。
  - 注意事项：
    - 若允许核心线程超时（通过allowCoreThreadTimeOut(true)），核心线程也会受此参数影响。
- 工作队列（workQueue）
  - 作用：用于保存等待执行任务的阻塞队列。
    常见类型：
    - 无界队列（如LinkedBlockingQueue）：可能导致内存溢出。
    - 有界队列（如ArrayBlockingQueue）：需合理设置容量。
    - 同步移交队列（如SynchronousQueue）：不存储任务，直接将任务交给线程。
  - 选择策略：
  - 任务量波动大时，优先使用有界队列避免资源耗尽。
  - 高吞吐场景可使用LinkedBlockingQueue，快速响应场景可使用SynchronousQueue。
- 线程工厂（threadFactory）
  - 作用：自定义线程创建方式，可设置线程名称、优先级、是否为守护线程等。
  - 示例：
```
ThreadFactory factory = r -> {
    Thread t = new Thread(r);
    t.setName("my-pool-" + t.getId());
    return t;
};
```
- 拒绝策略（RejectedExecutionHandler）
  - 作用：当线程池无法接受新任务（队列已满且线程数达上限）时的处理策略。
    常见策略：
    - AbortPolicy（默认）：抛出RejectedExecutionException。
    - CallerRunsPolicy：由提交任务的线程直接执行任务。
    - DiscardPolicy：静默丢弃被拒绝的任务。
    - DiscardOldestPolicy：丢弃队列中最旧的任务，并重新提交被拒绝的任务。
  - 自定义策略：可扩展RejectedExecutionHandler接口实现特定逻辑（如记录日志或重试）。
- 其他配置
  - allowCoreThreadTimeOut：允许核心线程因空闲超时被回收（需keepAliveTime > 0）。
  - 预热核心线程：通过prestartAllCoreThreads()提前启动所有核心线程。