当前位置：首页 > article >正文

【面试题系列】Java 多线程面试题深度解析

article 2025/2/23 22:57:48

在这里插入图片描述

本文涉及Java 多线程面试题，从基础到高级，希望对你有所帮助！

一、基础概念类

1. 请简述 Java 中线程的几种状态及其转换条件

题目分析：这是多线程基础中的基础，考查对线程生命周期的理解，在多线程编程中，线程状态的转换是核心机制之一。
答案：
Java 中线程有六种状态，定义在 Thread.State 枚举中：

NEW（新建）：线程被创建但还未调用 start() 方法。例如：

Thread thread = new Thread(() -> System.out.println("Running")); 
// 此时 thread 处于 NEW 状态

RUNNABLE（可运行）：线程调用 start() 方法后进入该状态，它可能正在运行，也可能在等待 CPU 时间片。
BLOCKED（阻塞）：线程在等待获取一个排它锁（synchronized 同步块）时进入该状态，当锁被释放且该线程竞争到锁时，会转换回 RUNNABLE 状态。

public class BlockedExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2 got the lock");
            }
        });
        t1.start();
        t2.start();
        // t2 可能会进入 BLOCKED 状态等待 lock
    }
}

WAITING（等待）：线程调用 Object.wait()、Thread.join() 或 LockSupport.park() 方法后进入该状态，需要其他线程调用 Object.notify()、Object.notifyAll() 或 LockSupport.unpark() 来唤醒。
TIMED_WAITING（计时等待）：与 WAITING 类似，但有时间限制，例如调用 Thread.sleep(long millis)、Object.wait(long timeout) 等方法。
TERMINATED（终止）：线程执行完毕或者因异常退出。

2. 什么是守护线程？有什么作用？

题目分析：守护线程是 Java 线程机制中的一个特殊概念，考查对线程不同类型及其用途的理解。
答案：
守护线程是一种特殊的线程，它的作用是为其他线程提供服务。当所有非守护线程结束时，守护线程会自动终止，即使它的任务还未完成。
在 Java 中，可以通过 setDaemon(true) 方法将线程设置为守护线程，且该方法必须在 start() 方法之前调用。例如：

Thread daemonThread = new Thread(() -> {
    while (true) {
        try {
            Thread.sleep(1000);
            System.out.println("Daemon thread is running");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
daemonThread.setDaemon(true);
daemonThread.start();

守护线程常用于垃圾回收、监控等服务，比如 JVM 的垃圾回收线程就是一个典型的守护线程。

二、同步与锁类

1. 请比较 `synchronized` 和 `ReentrantLock` 的异同

题目分析：这是多线程同步机制中的重点内容，synchronized 和 ReentrantLock 是常用的同步手段，考查对它们的理解和使用场景的掌握。
答案：
相同点：

都用于实现线程同步，保证同一时间只有一个线程可以访问共享资源。
都具有可重入性，即同一个线程可以多次获取同一把锁而不会发生死锁。

不同点：

语法层面：synchronized 是 Java 关键字，是内置的语言实现；ReentrantLock 是一个类，需要手动调用 lock() 和 unlock() 方法来加锁和解锁。

// synchronized 示例
public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }
}

// ReentrantLock 示例
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

灵活性：ReentrantLock 更加灵活，例如可以实现公平锁（new ReentrantLock(true)），还可以使用 tryLock() 方法尝试获取锁，避免线程长时间阻塞。
锁的释放：synchronized 会在同步块或方法执行完毕后自动释放锁；ReentrantLock 必须在 finally 块中手动调用 unlock() 方法释放锁，否则可能导致死锁。

2. 什么是死锁？如何避免死锁？

题目分析：死锁是多线程编程中常见且严重的问题，考查对死锁概念和解决方法的掌握。
答案：
死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。
死锁的产生需要满足四个必要条件：

互斥条件：进程对所分配到的资源进行排他性使用，即在一段时间内某资源只由一个进程占用。
请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
循环等待条件：在发生死锁时，必然存在一个进程——资源的环形链，即进程集合 {P0，P1，P2，···，Pn} 中的 P0 正在等待一个 P1 占用的资源；P1 正在等待 P2 占用的资源，……，Pn 正在等待已被 P0 占用的资源。

避免死锁的方法有：

破坏请求和保持条件：可以采用资源一次性分配的策略，即进程在运行前一次性申请它所需要的全部资源，在它的资源未满足前，不把它投入运行。
破坏不剥夺条件：允许进程剥夺使用其它进程占有的资源。
破坏循环等待条件：采用资源有序分配法，即把系统中的所有资源编号，进程在请求资源时，必须严格按资源编号的递增顺序进行，避免形成资源的环形链。
使用定时锁：例如 ReentrantLock 的 tryLock(long timeout, TimeUnit unit) 方法，在一定时间内无法获取锁时，线程可以放弃等待，避免死锁。

三、线程池类

1. 请简述 Java 中线程池的工作原理和主要参数

题目分析：线程池是 Java 多线程编程中的重要工具，考查对线程池内部机制和参数的理解。
答案：
工作原理：
线程池的核心思想是预先创建一定数量的线程，当有任务提交时，从线程池中获取线程来执行任务，任务执行完毕后线程不会销毁，而是返回线程池等待下一个任务。这样可以避免频繁创建和销毁线程带来的性能开销。
线程池的主要工作流程如下：

当有新任务提交时，首先检查线程池中的核心线程数是否达到 corePoolSize，如果未达到，则创建新的核心线程来执行任务。
如果核心线程数已达到 corePoolSize，则将任务放入阻塞队列中。
如果阻塞队列已满，且线程池中的线程数未达到 maximumPoolSize，则创建新的非核心线程来执行任务。
如果线程池中的线程数已达到 maximumPoolSize，且阻塞队列已满，则根据拒绝策略来处理新任务。

主要参数：

corePoolSize：核心线程数，线程池始终保持的线程数量。
maximumPoolSize：线程池允许的最大线程数。
keepAliveTime：非核心线程在空闲时的存活时间，超过该时间线程将被销毁。
TimeUnit：keepAliveTime 的时间单位。
BlockingQueue：阻塞队列，用于存储等待执行的任务。常见的阻塞队列有 ArrayBlockingQueue、LinkedBlockingQueue 等。
ThreadFactory：线程工厂，用于创建线程。
RejectedExecutionHandler：拒绝策略，当线程池和阻塞队列都已满时，如何处理新提交的任务。常见的拒绝策略有 AbortPolicy（直接抛出异常）、CallerRunsPolicy（由调用者线程执行任务）等。

2. 如何合理配置线程池的参数？

题目分析：这是线程池使用中的关键问题，合理配置参数可以提高线程池的性能和稳定性。
答案：
线程池参数的配置需要根据具体的业务场景和系统资源来决定，以下是一些参考原则：

corePoolSize：
- 对于 CPU 密集型任务（如计算、加密等），线程池的核心线程数可以设置为 CPU 核心数 + 1，这样可以充分利用 CPU 资源，避免线程上下文切换带来的开销。可以使用 Runtime.getRuntime().availableProcessors() 方法获取 CPU 核心数。
- 对于 I/O 密集型任务（如文件读写、网络请求等），线程池的核心线程数可以设置得大一些，一般可以设置为 CPU 核心数 * 2，因为 I/O 操作会使线程阻塞，此时可以让其他线程继续执行任务。
maximumPoolSize：
- 一般情况下，maximumPoolSize 可以设置为比 corePoolSize 大一些，以应对突发的任务高峰。但也不宜设置得过大，否则会占用过多的系统资源。
BlockingQueue：
- 对于任务执行时间较短、任务数量较多的场景，可以使用有界队列（如 ArrayBlockingQueue），避免队列无限增长导致内存溢出。
- 对于任务执行时间较长、任务数量较少的场景，可以使用无界队列（如 LinkedBlockingQueue），让任务在队列中等待执行。
keepAliveTime：
- 可以根据任务的执行频率和系统资源情况来设置，一般可以设置为几十秒到几分钟不等。如果任务执行频率较高，可以适当缩短 keepAliveTime；如果任务执行频率较低，可以适当延长 keepAliveTime。
RejectedExecutionHandler：
- 根据业务需求选择合适的拒绝策略。如果对任务丢失不敏感，可以选择 AbortPolicy；如果希望调用者线程来执行任务，可以选择 CallerRunsPolicy。

四、并发工具类类

1. 请简述 `CountDownLatch` 和 `CyclicBarrier` 的区别和使用场景

题目分析：CountDownLatch 和 CyclicBarrier 是 Java 并发包中常用的同步工具，考查对它们的功能和使用场景的理解。
答案：
区别：

计数机制：CountDownLatch 的计数器是递减的，初始值为需要等待的线程数量，每个线程完成任务后调用 countDown() 方法将计数器减 1，当计数器为 0 时，等待的线程可以继续执行；CyclicBarrier 的计数器是递增的，初始值为需要等待的线程数量，每个线程到达屏障时调用 await() 方法，当计数器达到初始值时，所有等待的线程同时继续执行，并且计数器可以重置，重复使用。
使用方式：CountDownLatch 主要用于一个或多个线程等待其他线程完成任务；CyclicBarrier 主要用于多个线程相互等待，达到一个共同的屏障点后再继续执行。

使用场景：

CountDownLatch：适用于一个主线程等待多个子线程完成任务的场景，例如在多线程下载中，主线程等待所有子线程下载完成后进行合并操作。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 3;
        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " is working");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        latch.await();
        System.out.println("All threads have finished their work");
    }
}

CyclicBarrier：适用于多个线程需要同步到某个点后再继续执行的场景，例如多个运动员在起跑线等待发令枪响后同时起跑。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int threadCount = 3;
        CyclicBarrier barrier = new CyclicBarrier(threadCount, () -> System.out.println("All threads have reached the barrier"));

        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " is waiting at the barrier");
                    barrier.await();
                    System.out.println(Thread.currentThread().getName() + " has passed the barrier");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

2. `Semaphore` 有什么作用？请举例说明

题目分析：Semaphore 是 Java 并发包中用于控制并发访问数量的工具，考查对其功能和使用场景的理解。
答案：
Semaphore 可以理解为一个信号量，它用于控制同时访问某个资源的线程数量。Semaphore 内部维护了一个计数器，线程在访问资源前需要先获取信号量（调用 acquire() 方法），计数器减 1；线程访问完资源后需要释放信号量（调用 release() 方法），计数器加 1。当计数器为 0 时，其他线程需要等待，直到有线程释放信号量。
使用场景包括限制并发访问资源的数量，例如数据库连接池、限流等。
以下是一个简单的示例，模拟多个线程同时访问有限的资源：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final int RESOURCE_COUNT = 3;
    private static final int THREAD_COUNT = 5;
    private static final Semaphore semaphore = new Semaphore(RESOURCE_COUNT);

    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                try {
                    // 获取信号量
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " has acquired the resource");
                    // 模拟使用资源
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放信号量
                    semaphore.release();
                    System.out.println(Thread.currentThread().getName() + " has released the resource");
                }
            }).start();
        }
    }
}