多线程常见面试题(详细回答附加代码举例)

Java全栈的牛马

于 2024-08-12 14:50:11 发布

阅读量637

点赞数 19

分类专栏： Java全栈面试宝典，每天发布12题文章标签： java 面试 jvm

本文链接：https://blog.csdn.net/qq_51263863/article/details/141131393

版权

Java全栈面试宝典，每天发布12题专栏收录该内容

7 篇文章 0 订阅

订阅专栏

问：什么是线程安全？如何实现线程安全？
答：线程安全是指在多线程环境下，程序能够正确地处理多个线程对共享资源的访问，使得程序的行为可预期。
实现线程安全的方法包括：

使用synchronized关键字
使用java.util.concurrent.locks包中的锁
使用线程安全的数据结构（如ConcurrentHashMap, CopyOnWriteArrayList等）
使用原子类（如AtomicInteger, AtomicReference等）
使用volatile关键字保证可见性
使用ThreadLocal实现线程本地存储
采用不可变对象

问：synchronized和Lock有什么区别？
答：主要区别如下：

synchronized是Java的关键字，Lock是一个接口
synchronized自动释放锁，Lock需要手动释放
synchronized不能中断一个正在等待获取锁的线程，Lock可以通过lockInterruptibly()
synchronized是非公平锁，Lock可以实现公平锁
Lock可以绑定多个Condition
Lock可以尝试非阻塞地获取锁（tryLock()）
Lock可以知道线程是否拿到了锁

问：什么是死锁？如何避免死锁？
答：死锁是指两个或多个线程互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。
避免死锁的方法：

按照固定的顺序获取锁
使用定时锁（如ReentrantLock的tryLock(long timeout, TimeUnit unit)）
检测和解除死锁（使用ThreadMXBean）
避免嵌套锁
使用开放调用（尽量不要在持有锁的情况下调用外部方法）

问：volatile关键字的作用是什么？
答：volatile关键字主要有两个作用：

保证变量的可见性：当一个线程修改了volatile变量的值，新值会立即被刷新到主内存中，其他线程读取时会直接从主内存中读取。
禁止指令重排序：防止编译器和处理器对volatile变量操作的重排序。
但是，volatile不能保证原子性。

问：ConcurrentHashMap的工作原理是什么？
答：ConcurrentHashMap采用分段锁（Segment）机制，每个Segment相当于一个小的HashMap，有自己的锁。这样，不同Segment上的操作可以并发进行，大大提高了并发性能。
在Java 8中，ConcurrentHashMap的实现有所改变，不再使用Segment，而是使用CAS操作和synchronized来保证并发安全。
问：线程池的工作原理是什么？
答：线程池的基本工作原理如下：
线程池维护一定数量的核心线程。
当新任务到来时，如果核心线程都在工作，任务会被放入队列中等待。
如果队列已满，且未达到最大线程数，会创建新的线程来处理任务。
如果达到最大线程数，会执行拒绝策略。
当线程空闲时间超过keepAliveTime，非核心线程会被回收。
问：如何在Java中实现生产者-消费者模型？
答：可以使用以下几种方式实现：
使用wait()和notify()/notifyAll()
使用BlockingQueue
使用Semaphore
使用Condition
这里是使用BlockingQueue的示例：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
class Producer implements Runnable {
    private final BlockingQueue<Integer> queue;
    Producer(BlockingQueue<Integer> q) { queue = q; }
    public void run() {
        try {
            for (int i = 0; i < 100; i++) {
                queue.put(i);
                System.out.println("Produced " + i);
            }
        } catch (InterruptedException ex) { }
    }
}
class Consumer implements Runnable {
    private final BlockingQueue<Integer> queue;
    Consumer(BlockingQueue<Integer> q) { queue = q; }
    public void run() {
        try {
            while (true) {
                Integer item = queue.take();
                System.out.println("Consumed " + item);
            }
        } catch (InterruptedException ex)

问：什么是ThreadLocal？它的使用场景是什么？
答：ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其他线程来说则无法获取到数据。
使用场景：

在一个线程中传递一些数据，避免通过参数传递
线程隔离，每个线程都有自己的独立副本
解决线程安全问题，如SimpleDateFormat的使用
示例：

public class ThreadLocalExample {
    private static final ThreadLocal<SimpleDateFormat> formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd HHmm"));
    public static void main(String[] args) {
        Runnable task = () -> {
            String birthDate = formatter.get().format(new Date());
            System.out.println(Thread.currentThread().getName() + ": birthDate = " + birthDate);
        };
        for (int i = 0; i < 10; i++) {
            new Thread(task).start();
        }
    }
}

问：什么是可重入锁？ReentrantLock是如何实现可重入的？
答：可重入锁是指同一个线程可以多次获取同一把锁，而不会造成死锁。
ReentrantLock通过在内部维护一个同步状态（sync state）来实现可重入性。当线程第一次获取锁时，ReentrantLock会记录当前线程的ID和锁的持有数量。当同一个线程再次获取锁时，只是简单地增加持有数量。释放锁时，持有数量会相应减少，直到变为0时，锁才被完全释放。
问：如何实现一个线程安全的单例模式？
答：有多种方法可以实现线程安全的单例模式，以下是一种常用的双重检查锁定（Double-Checked Locking）方式：

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

另一种更简单的方式是使用静态内部类：

public class Singleton {
    private Singleton() {}
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

问：Fork/Join框架是什么？它的工作原理是什么？
答：Fork/Join框架是Java 7引入的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。
工作原理：
Fork：把一个大任务切分为若干子任务
Join：等待所有子任务完成并得到结果
采用"工作窃取"算法，某个线程从其他队列里窃取任务来执行
示例：

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
public class FibonacciTask extends RecursiveTask<Integer> {
    final int n;
    FibonacciTask(int n) { this.n = n; }
    @Override
    protected Integer compute() {
        if (n <= 1)
            return n;
        FibonacciTask f1 = new FibonacciTask(n - 1);
        f1.fork();
        FibonacciTask f2 = new FibonacciTask(n - 2);
        return f2.compute() + f1.join();
    }
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        System.out.println(pool.invoke(new FibonacciTask(10)));
    }
}

问：什么是AQS（AbstractQueuedSynchronizer）？它是如何工作的？
答：AQS是Java并发包中的核心类，许多同步器（如ReentrantLock、Semaphore、CountDownLatch等）都是基于AQS实现的。
AQS的工作原理：
AQS使用一个int类型的成员变量state来表示同步状态
提供了getState()、setState()、compareAndSetState()等方法来操作状态
维护了一个FIFO的等待队列，用于存放等待的线程
子类通过继承并实现它的方法来管理状态（如acquire和release）
AQS支持两种同步方式：