Java笔试面试题AI答之线程（24）

工程师老罗

已于 2024-08-30 21:20:56 修改

阅读量1.1k

点赞数 17

分类专栏： Java笔试面试题AI答文章标签： java 开发语言

于 2024-08-25 12:23:15 首次发布

本文链接：https://blog.csdn.net/Lwjobs/article/details/141527681

版权

Java笔试面试题AI答专栏收录该内容

70 篇文章 0 订阅

订阅专栏

文章目录

139. 简述为什么 wait(), notify()和 notifyAll()必须在同步方法或者同步块中被调用？
140. 简述为什么 Thread 类的 sleep()和 yield ()方法是静态的？
141. 简述同步方法和同步块，哪个是更好的选择？
142. 简述如何创建守护线程？
143. 简述什么是 Java Timer 类？如何创建一个有特定时间间隔的任务？
- - 如何创建一个有特定时间间隔的任务？
144. 简述实现可见性的方法有哪些？

139. 简述为什么 wait(), notify()和 notifyAll()必须在同步方法或者同步块中被调用？

wait(), notify(), 和 notifyAll() 是 Java 中 Object 类提供的三个方法，它们被用于线程间的通信，特别是在多线程环境下需要协调线程之间的执行顺序时。这三个方法必须在同步方法或者同步块中被调用，原因如下：

确保对象锁定的一致性：
wait(), notify(), 和 notifyAll() 方法都是作用于某个对象锁之上的。当一个线程调用某个对象的 wait() 方法时，它会释放该对象锁并进入等待状态，直到其他线程在该对象上调用 notify() 或 notifyAll() 方法。如果这些方法不是在同步方法或同步块中调用，那么就无法确保调用它们的线程拥有该对象的锁。没有锁，这些方法的行为将是未定义的，因为它们依赖于锁来管理等待/通知的线程队列。
避免竞态条件：
在多线程环境中，如果没有适当的同步，就可能出现竞态条件，即两个或多个线程竞争执行同一资源，导致不可预测的结果。在调用 wait(), notify(), 和 notifyAll() 时，如果没有同步控制，就可能发生线程在错误的时间释放或获取锁，从而破坏了线程间的通信逻辑。
保证线程安全：
同步方法或同步块确保了只有持有对象锁的线程才能执行其中的代码。这保证了在同一时刻，只有一个线程可以修改共享资源或执行与等待/通知相关的操作，从而保证了线程安全。
Java 语言的规范：
根据 Java 语言的规范，wait(), notify(), 和 notifyAll() 方法必须在同步上下文中被调用。如果尝试在非同步环境中调用这些方法，Java 虚拟机将抛出一个 IllegalMonitorStateException 异常。这个异常是运行时异常，表明线程尝试执行了一个非法操作，因为它没有持有对象的锁。

综上所述，wait(), notify(), 和 notifyAll() 方法必须在同步方法或同步块中被调用，以确保线程间的正确通信和共享资源的安全访问。

140. 简述为什么 Thread 类的 sleep()和 yield ()方法是静态的？

Thread 类的 sleep() 和 yield() 方法被设计为静态方法，这主要是基于它们在多线程编程中的特定用途和调用方式。以下是详细解释：

1. sleep() 方法

静态原因：sleep() 方法的作用是使当前正在执行的线程暂停执行指定的时间（以毫秒或纳秒为单位）。由于这个操作是针对当前正在执行的线程，而不是某个特定的 Thread 对象，因此将 sleep() 方法设计为静态方法是有意义的。这样，无论在哪个线程中调用 sleep()，都是让当前线程进入休眠状态，而不是其他线程。
避免误解：如果 sleep() 不是静态的，那么程序员可能会误以为需要在一个特定的 Thread 对象上调用它，从而错误地认为能够控制其他线程的休眠。而实际上，每个线程只能控制自己的休眠。

2. yield() 方法

静态原因：yield() 方法的作用是提示调度器当前线程愿意放弃当前的 CPU 时间片，以便其他线程有机会运行。与 sleep() 方法类似，yield() 也是作用于当前正在执行的线程，而不是某个特定的 Thread 对象。因此，将其设计为静态方法可以避免混淆。
线程协作：yield() 方法是一种线程间的协作机制，它并不保证其他线程会立即运行，而是通知操作系统当前线程愿意让出 CPU。这种机制有助于在多线程环境中提高 CPU 的利用率和任务的响应性。

总结

Thread 类的 sleep() 和 yield() 方法被设计为静态方法，主要是因为它们都是作用于当前正在执行的线程，而不是某个特定的 Thread 对象。这种设计方式避免了程序员在调用这些方法时可能产生的误解，并简化了多线程编程的复杂性。同时，这也符合 Java 编程语言的设计哲学，即尽可能减少不必要的对象创建和状态管理，以提高程序的性能和可维护性。

141. 简述同步方法和同步块，哪个是更好的选择？

在Java中，同步方法和同步块都是用来控制多线程访问共享资源的手段，它们各有优缺点，哪个是更好的选择取决于具体的应用场景和需求。

同步方法

优点：

简单易用：只需在方法声明时添加synchronized关键字，即可实现对该方法的同步访问，代码量少，易于维护。
锁范围明确：同步方法会锁住整个方法，对于需要保护整个方法体不被并发访问的场景非常适用。

缺点：

锁范围可能过大：如果方法体中有部分代码并不需要同步，那么使用同步方法会导致不必要的性能开销。
灵活性差：一旦方法被声明为同步的，就无法通过其他方式（如条件变量）来优化同步策略。

同步块

优点：

锁范围可控：同步块允许开发者精确地控制需要同步的代码区域，从而避免对整个方法的锁定，提高并发性能。
灵活性高：可以通过选择不同的锁对象来实现更复杂的同步策略，如使用条件变量等。

缺点：

使用复杂：相对于同步方法，同步块需要开发者手动指定锁对象和同步范围，增加了编码的复杂性。
易出错：如果锁对象选择不当或同步范围设置不合理，可能会导致死锁等问题。

选择建议

如果整个方法都需要同步：并且没有性能上的特别要求，那么使用同步方法是一个简单且有效的选择。
如果只需要同步方法中的部分代码：或者希望通过更灵活的同步策略来提高并发性能，那么应该选择同步块。

在实际开发中，还需要考虑其他因素，如锁对象的选择、锁的粒度、同步块的嵌套等。此外，为了避免死锁和提高并发性能，还需要注意避免过度同步和合理使用锁对象。

综上所述，同步方法和同步块各有优势，选择哪个更好取决于具体的应用场景和需求。在编写多线程程序时，应该根据实际情况灵活选择，以实现高效、稳定的并发控制。

142. 简述如何创建守护线程？

在Java中，守护线程（Daemon Thread）是一种特殊的线程，它主要为其他线程（即用户线程）提供服务。当程序中所有的用户线程都结束时，守护线程会自动结束，而不需要显式地终止它们。守护线程通常用于执行“后台”任务，比如垃圾回收、计时器线程等。

要创建一个守护线程，可以通过以下步骤进行：

创建线程：首先，你需要创建一个Thread的实例，或者继承自Thread类的子类的一个实例。这通常涉及到实现Runnable接口或继承Thread类并重写run方法。
设置守护线程：在启动线程之前，通过调用线程的setDaemon(true)方法将该线程设置为守护线程。注意，这一步骤必须在调用线程的start()方法之前完成，因为一旦线程开始执行，就不能再更改其守护线程状态了。
启动线程：通过调用线程的start()方法来启动线程。此时，如果该线程是守护线程，它将按照守护线程的规则执行。

下面是一个简单的示例，展示了如何创建并启动一个守护线程：

public class DaemonThreadExample {
    public static void main(String[] args) {
        // 创建一个Runnable实例
        Runnable task = new Runnable() {
            @Override
            public void run() {
                // 守护线程的执行逻辑
                while (true) {
                    try {
                        System.out.println("守护线程正在运行...");
                        Thread.sleep(1000); // 假设这里执行一些耗时操作
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        // 创建Thread实例，并设置为守护线程
        Thread daemonThread = new Thread(task);
        daemonThread.setDaemon(true); // 设置为守护线程

        // 启动线程
        daemonThread.start();

        // 主线程（用户线程）执行一些操作后结束
        try {
            // 假设主线程等待3秒后结束
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 主线程结束，由于没有其他用户线程在运行，守护线程也将自动结束
        System.out.println("主线程结束，程序退出。");
    }
}

需要注意的是，在上面的示例中，虽然守护线程的执行逻辑是一个无限循环，但由于主线程（也是唯一的用户线程）在一段时间后结束，JVM将退出，同时守护线程也会被终止。这展示了守护线程的一个关键特性：它们不会阻止JVM的退出。如果JVM中只剩下守护线程在运行，那么JVM将正常退出。

143. 简述什么是 Java Timer 类？如何创建一个有特定时间间隔的任务？

Java 中的 Timer 类是一个工具类，用于在后台线程中安排任务进行单次或重复执行。它提供了一种简单的方式来调度任务在将来的某个时间执行，或者定期地执行。Timer 类属于 java.util 包，并且它基于 java.util.TaskQueue，这个队列中包含了所有等待执行的任务。

如何创建一个有特定时间间隔的任务？

要创建一个有特定时间间隔的任务，你需要做以下几步：

创建 TimerTask 类的一个子类：这个子类需要重写 run() 方法，该方法包含了你想定时执行的任务代码。
创建 Timer 对象：使用 new Timer() 创建一个 Timer 类的实例。
安排任务：通过调用 Timer 对象的 schedule 方法之一来安排你的 TimerTask 实例。对于需要定期执行的任务，可以使用 schedule(TimerTask task, long delay, long period) 方法。其中，delay 是任务开始前的延迟时间（以毫秒为单位），period 是任务连续执行之间的时间间隔（同样以毫秒为单位）。

下面是一个简单的示例代码，展示了如何创建一个每隔特定时间间隔（比如每3秒）执行一次的任务：

import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {

    public static void main(String[] args) {

        // 创建一个 Timer 实例
        Timer timer = new Timer();

        // 创建一个 TimerTask 实例，该实例重写了 run 方法来定义要执行的任务
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                // 在这里写你的任务代码
                System.out.println("Task executed: " + System.currentTimeMillis());
            }
        };

        // 安排任务在 0 毫秒后开始执行，之后每隔 3000 毫秒（3秒）执行一次
        timer.schedule(task, 0, 3000);

        // 注意：通常，为了让程序持续运行，你可能需要在某个地方（如 main 方法中）添加一些等待逻辑
        // 例如，可以使用 Scanner 类等待用户输入，或者使用 Thread.sleep() 让主线程休眠一段时间
        // 但在这个简单的示例中，我们没有这样做
    }
}

注意：在实际应用中，如果你不需要在程序结束时保持 Timer 线程运行，你可能需要在适当的时候调用 timer.cancel() 方法来取消定时器，并释放与之关联的资源。另外，Timer 类及其任务执行并不保证非常精确的时间间隔，因为它们受到系统调度和其他线程执行的影响。如果需要更高精度的时间控制，可能需要考虑使用 ScheduledExecutorService。

144. 简述实现可见性的方法有哪些？

实现可见性的方法主要依赖于编程语言和并发模型的特性。以下是一些常见的实现可见性的方法，这些方法特别适用于多线程编程环境：

1. 使用volatile关键字

在Java等编程语言中，volatile关键字用于修饰变量，确保对该变量的写操作对其他线程是立即可见的。当一个线程修改了volatile变量的值后，新值会立即被写入主内存，并且其他线程读取该变量时会直接从主内存中获取最新值，而不是从自己的缓存中读取。这种方式确保了变量修改的可见性。

2. 使用锁机制

锁机制，如Java中的synchronized关键字或Lock接口的实现类（如ReentrantLock），也可以实现可见性。当一个线程通过锁机制访问共享资源时，它会先获取锁，然后执行对共享资源的操作，并在操作完成后释放锁。在持有锁期间，线程对共享资源的修改对其他线程是不可见的，但一旦锁被释放，其他线程就能看到最新的修改结果。这是因为锁机制通常包含了内存屏障（Memory Barrier），用于确保锁的获取和释放操作具有适当的内存可见性语义。

3. 使用原子类

Java的java.util.concurrent.atomic包提供了一系列原子类，如AtomicInteger、AtomicLong等。这些类利用底层的CAS（Compare-And-Swap）操作或其他同步机制来确保对共享变量的操作是原子的，并且具有可见性。原子类通常用于实现计数器、累加器等场景，它们能够在多线程环境中安全地更新变量值，而无需使用锁。

4. 使用并发容器和工具类

Java还提供了一些线程安全的并发容器（如ConcurrentHashMap、ConcurrentLinkedQueue等）和工具类（如CountDownLatch、CyclicBarrier等），这些容器和工具类内部实现了适当的同步机制，以确保对共享数据的访问是线程安全的，并且具有可见性。使用这些并发容器和工具类可以避免手动编写复杂的同步代码，从而简化多线程编程。