java2025年多线程热点面试题第一弹

1. Java中创建线程的几种方式有哪些？

答案：

1. 继承Thread类：

   class MyThread extends Thread {
       @Override
       public void run() {
           System.out.println("Thread is running.");
       }
   }
   new MyThread().start();
   

2. 实现Runnable接口：

   class MyRunnable implements Runnable {
       @Override
       public void run() {
           System.out.println("Thread is running.");
       }
   }
   new Thread(new MyRunnable()).start();
   

3. 实现Callable接口（支持返回值和异常）：

   class MyCallable implements Callable<String> {
       @Override
       public String call() throws Exception {
           return "Thread is running.";
       }
   }
   FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
   new Thread(futureTask).start();
   System.out.println(futureTask.get());
   

4. 使用线程池：

   ExecutorService executor = Executors.newSingleThreadExecutor();
   executor.submit(() -> System.out.println("Thread is running."));
   executor.shutdown();
   

2. Java中的wait()和sleep()的区别是什么？

答案：

• wait()：

  • 是Object类的方法，必须在同步方法或同步代码块中使用。
  • 释放当前线程持有的锁，进入等待状态，直到被其他线程唤醒。
  • 可以指定等待时间，超时后线程会自动唤醒。
  • 示例：

    synchronized (obj) {
        obj.wait();
    }
    

• sleep()：

  • 是Thread类的静态方法，不会释放锁。
  • 线程暂停指定时间后自动恢复运行。
  • 示例：

    Thread.sleep(1000);
    

3. 如何实现线程间的通信？

答案：
线程间通信可以通过以下方式实现：

1. 使用wait()和notify()/notifyAll()：

   • wait()：线程释放锁并进入等待状态。
   • notify()/notifyAll()：唤醒等待中的线程。
   • 示例：

     class SharedResource {
         private boolean available = false;
     
         public synchronized void produce() throws InterruptedException {
             while (available) {
                 wait();
             }
             System.out.println("Produced");
             available = true;
             notifyAll();
         }
     
         public synchronized void consume() throws InterruptedException {
             while (!available) {
                 wait();
             }
             System.out.println("Consumed");
             available = false;
             notifyAll();
         }
     }
     

2. 使用java.util.concurrent包中的工具类：

   • BlockingQueue：线程安全的队列，支持阻塞操作。
   • 示例：

     BlockingQueue<String> queue = new LinkedBlockingQueue<>(1);
     queue.put("Item");
     String item = queue.take();
     

4. Java中的线程池有哪些类型？

答案：
Java提供了多种线程池类型，每种类型适用于不同的场景：

1. Executors.newFixedThreadPool(int n)：

   • 创建一个固定大小的线程池，线程数为n。
   • 适用于任务数量较多且线程数固定的场景。

2. Executors.newSingleThreadExecutor()：

   • 创建一个单线程的线程池，所有任务按顺序执行。
   • 适用于任务需要按顺序执行的场景。

3. Executors.newCachedThreadPool()：

   • 创建一个可缓存的线程池，线程数根据任务数量动态调整。
   • 适用于任务数量不确定且线程数需要动态调整的场景。

4. Executors.newScheduledThreadPool(int corePoolSize)：

   • 创建一个支持定时任务的线程池。
   • 示例：

     ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
     executor.scheduleAtFixedRate(() -> System.out.println("Task executed"), 0, 1, TimeUnit.SECONDS);
     

5. 如何避免线程安全问题？

答案：
避免线程安全问题可以通过以下方式：

1. 使用同步机制：

   • synchronized方法或代码块。
   • 示例：

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

2. 使用java.util.concurrent包中的工具类：

   • ConcurrentHashMap：线程安全的哈希表。
   • AtomicInteger：线程安全的整数。
   • 示例：

     AtomicInteger count = new AtomicInteger(0);
     count.incrementAndGet();
     

3. 使用不可变对象：

   • 不可变对象（如String、Integer）是线程安全的，因为它们的状态不可变。

4. 使用锁（ReentrantLock）：

   • 示例：

     Lock lock = new ReentrantLock();
     lock.lock();
     try {
         // Critical section
     } finally {
         lock.unlock();
     }
     

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

答案：

• volatile用于修饰变量，确保变量的读写操作对所有线程可见。
• 它可以防止指令重排序，但不能保证复合操作的原子性。
• 示例：

  private volatile boolean running = true;
  
  public void run() {
      while (running) {
          // Do something
      }
  }
  

7. 如何实现线程的中断？

答案：
线程可以通过以下方式中断：

1. 调用Thread.interrupt()方法：

   • 设置线程的中断状态。
   • 示例：

     Thread thread = new Thread(() -> {
         while (!Thread.currentThread().isInterrupted()) {
             // Do something
         }
     });
     thread.start();
     thread.interrupt();
     

2. 在run()方法中检查中断状态：

   • 使用Thread.currentThread().isInterrupted()检查线程是否被中断。
   • 示例：

     public void run() {
         while (!Thread.currentThread().isInterrupted()) {
             // Do something
         }
     }
     

8. Java中的Future和CompletableFuture的区别是什么？

答案：

• Future：

  • 用于异步任务的结果。
  • 提供get()方法获取任务结果，但不支持回调。
  • 示例：

    Future<String> future = executor.submit(() -> "Result");
    String result = future.get();
    

• CompletableFuture：

  • 是Future的增强版本，支持链式调用和回调。
  • 提供thenApply、thenAccept、thenCombine等方法。
  • 示例：

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Result");
    future.thenAccept(System.out::println);
    

9. 如何实现线程的同步？

答案：
线程同步可以通过以下方式实现：

1. 使用synchronized关键字：

   • 示例：

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

2. 使用锁（ReentrantLock）：

   • 示例：

     Lock lock = new ReentrantLock();
     lock.lock();
     try {
         // Critical section
     } finally {
         lock.unlock();
     }
     

3. 使用java.util.concurrent包中的同步工具类：

   • Semaphore：信号量，用于控制同时访问某个资源的线程数量。
   • 示例：

     Semaphore semaphore = new Semaphore(2);
     semaphore.acquire();
     semaphore.release();
     

10. Java中的线程池如何管理线程的生命周期？

答案：
线程池通过以下方式管理线程的生命周期：

1. 线程的创建：

   • 线程池在初始化时创建一定数量的线程。
   • 当任务提交时，线程池会根据当前线程数和任务队列的状态决定是否创建新线程。

2. 线程的执行：

   • 线程从任务队列中获取任务并执行。
   • 如果任务队列为空，线程会等待新任务。

3. 线程的销毁：

   • 线程池会根据配置的keepAliveTime和corePoolSize决定是否销毁空闲线程。
   • 当线程池关闭时（调用shutdown()或shutdownNow()