中级：多线程面试题必知必会

一、引言

在Java开发中，多线程是构建高性能应用程序的关键技术之一。面试官通过相关问题考察候选人对多线程的理解深度、并发编程的能力以及在实际开发中解决并发问题的经验。本文将深入剖析常见的多线程面试题，结合实际开发场景，帮助读者全面掌握这些知识点。

二、多线程基础

1. 面试题：什么是多线程？为什么要使用多线程？
   • 答案 ：多线程是指程序中可以同时运行多个线程，每个线程执行特定的任务。使用多线程可以充分利用多核处理器的资源，提高程序的执行效率，同时可以实现并发操作，提升程序的响应速度。
   • 代码示例（创建线程） ：

     • public class MultiThreadExample {
           public static void main(String[] args) {
               Thread thread1 = new Thread(() -> {
                   for (int i = 0; i < 5; i++) {
                       System.out.println("线程1运行：" + i);
                       try {
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               });
       
               Thread thread2 = new Thread(() -> {
                   for (int i = 0; i < 5; i++) {
                       System.out.println("线程2运行：" + i);
                       try {
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               });
       
               thread1.start();
               thread2.start();
           }
       }
       

   • 踩坑经验 ：在创建线程时，需要注意线程的启动方式，使用start()方法启动线程，而不是直接调用run()方法，否则将无法实现真正的多线程。

三、线程安全

1. 面试题：什么是线程安全？如何保证线程安全？
   • 答案 ：线程安全是指在多线程环境下，多个线程访问共享资源时，程序的行为是正确且可预测的。保证线程安全的方法包括使用同步机制（如synchronized关键字）、使用并发工具类（如Lock接口的实现类）、避免共享可变数据等。
   • 代码示例（使用synchronized保证线程安全） ：

     • public class ThreadSafeExample {
           private int count = 0;
       
           public synchronized void increment() {
               count++;
           }
       
           public synchronized int getCount() {
               return count;
           }
       
           public static void main(String[] args) {
               final ThreadSafeExample example = new ThreadSafeExample();
       
               Thread thread1 = new Thread(() -> {
                   for (int i = 0; i < 1000; i++) {
                       example.increment();
                   }
               });
       
               Thread thread2 = new Thread(() -> {
                   for (int i = 0; i < 1000; i++) {
                       example.increment();
                   }
               });
       
               thread1.start();
               thread2.start();
       
               try {
                   thread1.join();
                   thread2.join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
       
               System.out.println("最终计数：" + example.getCount());
           }
       }
       

   • 踩坑经验 ：在使用同步机制时，需要注意同步的范围，尽量缩小同步代码块的范围，以减少线程之间的竞争，提高程序的并发性能。

四、锁机制

1. 面试题：synchronized和ReentrantLock有什么区别？
   • 答案 ：synchronized是Java语言内置的同步机制，使用简单，但功能相对有限。ReentrantLock是java.util.concurrent.locks包中的锁实现，提供了更丰富的功能，如尝试非阻塞地获取锁、可中断地获取锁等。
   • 代码示例（使用ReentrantLock） ：

     • import java.util.concurrent.locks.Lock;
       import java.util.concurrent.locks.ReentrantLock;
       
       public class ReentrantLockExample {
           private int count = 0;
           private final Lock lock = new ReentrantLock();
       
           public void increment() {
               lock.lock();
               try {
                   count++;
               } finally {
                   lock.unlock();
               }
           }
       
           public int getCount() {
               return count;
           }
       
           public static void main(String[] args) {
               final ReentrantLockExample example = new ReentrantLockExample();
       
               Thread thread1 = new Thread(() -> {
                   for (int i = 0; i < 1000; i++) {
                       example.increment();
                   }
               });
       
               Thread thread2 = new Thread(() -> {
                   for (int i = 0; i < 1000; i++) {
                       example.increment();
                   }
               });
       
               thread1.start();
               thread2.start();
       
               try {
                   thread1.join();
                   thread2.join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
       
               System.out.println("最终计数：" + example.getCount());
           }
       }
       

   • 踩坑经验 ：在使用ReentrantLock时，必须确保在finally块中释放锁，避免因异常导致锁无法释放，造成其他线程无法获取锁。

五、线程池

1. 面试题：什么是线程池？为什么要使用线程池？
   • 答案 ：线程池是一组预先创建的、可重复使用的线程的集合。使用线程池可以避免频繁地创建和销毁线程带来的性能开销，提高程序的响应速度和资源利用率。
   • 代码示例（使用线程池） ：

     • import java.util.concurrent.ExecutorService;
       import java.util.concurrent.Executors;
       
       public class ThreadPoolExample {
           public static void main(String[] args) {
               ExecutorService executorService = Executors.newFixedThreadPool(2);
       
               executorService.submit(() -> {
                   for (int i = 0; i < 5; i++) {
                       System.out.println("任务1运行：" + i);
                       try {
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               });
       
               executorService.submit(() -> {
                   for (int i = 0; i < 5; i++) {
                       System.out.println("任务2运行：" + i);
                       try {
                           Thread.sleep(100);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
               });
       
               executorService.shutdown();
           }
       }
       

   • 踩坑经验 ：在使用线程池时，需要注意线程池的大小设置，根据系统的资源和任务的特性合理配置线程池大小，避免因线程过多导致资源耗尽或因线程过少导致资源利用率不足。

六、并发工具类

1. 面试题：什么是CountDownLatch？如何使用它？
   • 答案 ：CountDownLatch是一个同步辅助类，允许一个或多个线程等待其他线程完成操作。它通过一个计数器来实现，计数器的值必须在释放等待线程之前减到零。
   • 代码示例（使用CountDownLatch） ：

     • import java.util.concurrent.CountDownLatch;
       
       public class CountDownLatchExample {
           public static void main(String[] args) {
               CountDownLatch latch = new CountDownLatch(2);
       
               Thread task1 = new Thread(() -> {
                   System.out.println("任务1开始");
                   try {
                       Thread.sleep(1000);
                       System.out.println("任务1完成");
                       latch.countDown();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               });
       
               Thread task2 = new Thread(() -> {
                   System.out.println("任务2开始");
                   try {
                       Thread.sleep(2000);
                       System.out.println("任务2完成");
                       latch.countDown();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               });
       
               Thread task3 = new Thread(() -> {
                   try {
                       latch.await();
                       System.out.println("所有任务完成，执行后续操作");
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               });
       
               task1.start();
               task2.start();
               task3.start();
           }
       }
       

   • 踩坑经验 ：在使用CountDownLatch时，需要注意计数器的初始值和countDown()、await()方法的调用逻辑，确保线程等待和通知的正确性。

七、总结

多线程是Java编程中构建高性能应用程序的关键技术，面试中对多线程的考察主要集中在多线程基础、线程安全、锁机制、线程池以及并发工具类等方面。通过本文的学习，读者可以深入理解这些知识点，并通过代码示例掌握其实际应用。在实际开发中，合理运用多线程技术可以提高程序的性能和响应速度。

如果你觉得这篇文章对你有帮助，欢迎点赞、评论和关注，我会持续输出更多优质的技术内容。