Java多线程面试深度解析：从基础到高级，助你通关面试

Java多线程是面试中的常见考点，也是开发高并发应用的关键技术。本文将深入解析Java多线程面试中常见的问题，从基础概念到高级应用，助你充分准备面试，并在实际工作中灵活运用多线程技术。

1. 线程与进程的区别？

在探讨多线程之前，理解线程和进程的区别至关重要。

• 进程：是操作系统资源分配的基本单位，拥有独立的内存空间和系统资源。
• 线程：是进程中执行的最小单元，共享进程的内存空间和系统资源。

一个进程可以包含多个线程，它们共享进程的资源，但拥有独立的栈空间和程序计数器。

举例说明：可以将进程比作一家公司，而线程则是公司里的员工。公司（进程）拥有自己的办公场所、设备等资源，员工（线程）在公司内部协同工作，共享公司的资源，但每位员工都有自己的工作任务和职责。

2. Java中创建线程的方式有哪些？

Java提供了多种创建线程的方式：

• 继承Thread类：创建一个继承自Thread类的子类，并重写run()方法，然后创建该子类的实例并调用start()方法启动线程。
• 实现Runnable接口：创建一个实现了Runnable接口的类，实现run()方法，然后创建一个Thread对象，并将Runnable接口的实例作为参数传递给Thread的构造函数，最后调用start()方法启动线程。
• 使用Executor框架：使用Executor框架可以更方便地管理和控制线程，例如使用ThreadPoolExecutor创建线程池。
• 使用Callable和Future：Callable接口类似于Runnable接口，但Callable可以返回一个结果，而Runnable不能。Future接口可以用来获取Callable的执行结果。

代码示例：

// 继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running: " + Thread.currentThread().getName());
    }
}

public class ThreadCreationExample {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();

        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

3. 线程的生命周期是怎样的？

Java线程的生命周期包括以下几个阶段：

• 新建（New）：线程被创建但尚未启动。
• 就绪（Runnable）：线程已准备好运行，等待CPU调度。
• 运行（Running）：线程正在执行。
• 阻塞（Blocked）：线程因为某种原因暂停执行，例如等待锁、等待I/O等。
• 等待（Waiting）：线程进入等待状态，需要被其他线程显式地唤醒。
• 超时等待（Timed Waiting）：线程进入等待状态，但设置了超时时间，超时后自动唤醒。
• 终止（Terminated）：线程执行完毕或因异常而终止。

理解线程的生命周期有助于我们更好地理解线程的状态和行为，从而更好地控制和管理线程。

4. 什么是线程安全问题？如何解决？

当多个线程同时访问共享资源时，可能会出现线程安全问题，例如数据竞争、死锁等。解决线程安全问题的常用方法包括：

• 使用锁：使用synchronized关键字或Lock接口可以保证同一时间只有一个线程可以访问共享资源。
• 使用原子类：java.util.concurrent.atomic包提供了一系列原子类，可以保证对单个变量的操作是原子性的。
• 使用并发集合：java.util.concurrent包提供了一系列并发集合，例如ConcurrentHashMap、CopyOnWriteArrayList等，可以保证在多线程环境下的线程安全。
• 使用ThreadLocal：ThreadLocal可以为每个线程创建一个独立的变量副本，避免多个线程同时访问同一个变量。

代码示例：

// 使用synchronized关键字
class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

// 使用Lock接口
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class CounterWithLock {
    private int count = 0;
    private Lock lock = new ReentrantLock();

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

    public int getCount() {
        return count;
    }
}

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

死锁是指两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行的状态。

死锁产生的条件：

• 互斥条件：资源只能被一个线程占用。
• 请求与保持条件：线程已经占有至少一个资源，但又请求新的资源。
• 不可剥夺条件：线程已经获得的资源不能被其他线程强制剥夺。
• 循环等待条件：多个线程形成循环等待资源的关系。

避免死锁的方法：

• 避免持有多个锁：尽量减少线程持有锁的数量。
• 使用定时锁：使用tryLock()方法可以设置超时时间，避免线程无限等待。
• 避免循环等待：打破循环等待的条件，例如使用固定的锁获取顺序。

代码示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockExample {
    private static Lock lock1 = new ReentrantLock();
    private static Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                lock1.lock();
                System.out.println("Thread 1: Holding lock 1...");
                Thread.sleep(10);

                System.out.println("Thread 1: Waiting for lock 2...");
                lock2.lock();
                System.out.println("Thread 1: Holding lock 1 & 2...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock1.unlock();
                lock2.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                lock2.lock();
                System.out.println("Thread 2: Holding lock 2...");
                Thread.sleep(10);

                System.out.println("Thread 2: Waiting for lock 1...");
                lock1.lock();
                System.out.println("Thread 2: Holding lock 2 & 1...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

6. 什么是volatile关键字？它的作用是什么？

volatile关键字用于声明Java变量，它可以保证变量的可见性和禁止指令重排序。

• 可见性：当一个线程修改了volatile变量的值，其他线程可以立即看到修改后的值。
• 禁止指令重排序：volatile可以防止编译器和处理器对指令进行重排序，保证程序的执行顺序。

注意：volatile不能保证原子性，只能保证可见性和禁止指令重排序。

代码示例：

public class VolatileExample {
    private volatile boolean running = true;

    public void start() {
        new Thread(() -> {
            while (running) {
                // 执行任务
                System.out.println("Thread running...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Thread stopped.");
        }).start();
    }

    public void stop() {
        running = false;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileExample example = new VolatileExample();
        example.start();

        Thread.sleep(1000);
        example.stop();
    }
}

7. 什么是synchronized关键字？它有哪些用法？

synchronized关键字用于实现Java中的同步机制，它可以保证同一时间只有一个线程可以访问被synchronized修饰的代码块或方法。

用法：

• 同步方法：将synchronized关键字放在方法声明中，可以保证同一时间只有一个线程可以执行该方法。
• 同步代码块：使用synchronized关键字修饰代码块，可以指定锁的对象，只有获得锁的线程才能执行该代码块。

代码示例：

// 同步方法
class SynchronizedMethodExample {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

// 同步代码块
class SynchronizedBlockExample {
    private int count = 0;
    private Object lock = new Object();

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

    public int getCount() {
        return count;
    }
}

8. 什么是Lock接口？它与synchronized关键字有什么区别？

Lock接口是Java 5中引入的新的锁机制，它提供了比synchronized关键字更强大的功能。

区别：

• 灵活性：Lock接口提供了更多的灵活性，例如可以设置超时时间、可以中断等待等。
• 性能：在某些情况下，Lock接口的性能可能比synchronized关键字更好。
• 功能：Lock接口提供了更多的功能，例如公平锁、读写锁等。

代码示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class LockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();

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

    public int getCount() {
        return count;
    }
}

9. 什么是线程池？为什么要使用线程池？

线程池是一种线程管理机制，它可以预先创建一些线程，并将任务提交给线程池来执行，避免频繁地创建和销毁线程。

使用线程池的好处：

• 提高性能：避免频繁地创建和销毁线程，减少系统开销。
• 提高响应速度：任务可以立即被线程池中的线程执行，无需等待线程创建。
• 提高线程管理能力：线程池可以统一管理和控制线程，例如设置最大线程数、设置线程空闲时间等。

代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            int task = i;
            executor.execute(() -> {
                System.out.println("Task " + task + " running: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }
        System.out.println("All tasks finished.");
    }
}

10. 什么是CAS？它在并发编程中有什么应用？

CAS（Compare and Swap）是一种无锁算法，它可以原子性地比较并交换变量的值。

原理：CAS操作包含三个操作数：内存地址V、预期值A和新值B。如果内存地址V的值等于预期值A，则将内存地址V的值更新为新值B，否则不进行任何操作。

应用：CAS广泛应用于并发编程中，例如原子类、并发集合等。

代码示例：

import java.util.concurrent.atomic.AtomicInteger;

public class CASExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        int oldValue;
        int newValue;
        do {
            oldValue = count.get();
            newValue = oldValue + 1;
        } while (!count.compareAndSet(oldValue, newValue));
    }

    public int getCount() {
        return count.get();
    }

    public static void main(String[] args) {
        CASExample example = new CASExample();
        for (int i = 0; i < 1000; i++) {
            new Thread(example::increment).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + example.getCount());
    }
}

掌握这些Java多线程面试题，能够帮助你更好地应对面试挑战，并在实际工作中更加熟练地运用多线程技术，开发出高性能、高并发的应用。