初识Java并发，一问读懂Java并发知识文集(3)

发布时间：2023年12月30日

在这里插入图片描述

🏆作者简介，普修罗双战士，一直追求不断学习和成长，在技术的道路上持续探索和实践。
🏆多年互联网行业从业经验，历任核心研发工程师，项目技术负责人。
🎉欢迎 👍点赞?评论?收藏

Java注解知识专栏学习

Java并发知识云集访问地址备注
Java并发知识点(1)https://blog.csdn.net/m0_50308467/article/details/135216289Java并发专栏
Java并发知识点(2)https://blog.csdn.net/m0_50308467/article/details/135260439Java并发专栏
Java并发知识点(3)https://blog.csdn.net/m0_50308467/article/details/135301948Java并发专栏

文章目录

🏆 初识Java并发编程

🔎 Java 并发编程面试题(3)

🍁🍁 01、在Java中wait和sleep方法的不同？

在Java中，wait() 和 sleep() 是用于线程间的暂停执行的两个方法，但它们有一些重要的不同之处：

  1. 调用方式和位置不同：wait() 方法是在对象上调用的，而 sleep() 方法是在线程上调用的。wait() 方法必须在同步代码块或同步方法中使用，并且它会释放对象的锁，使其他线程可以访问该对象。sleep() 方法可以在任何地方使用，不会释放任何锁。

  2. 使用方式不同：wait() 方法通常与 notify() 或 notifyAll() 方法一起使用，用于实现线程间的通信和同步。wait() 方法使线程进入等待状态，直到其他线程调用相同对象上的 notify() 或 notifyAll() 方法来唤醒等待的线程。sleep() 方法是简单地让线程暂停执行一段预定的时间。

  3. 抛出异常不同：wait() 方法需要处理 InterruptedException 异常，它可能在等待过程中被中断而提前返回。sleep() 方法也可以处理 InterruptedException 异常，但通常不常用，并且在使用时需要谨慎处理中断状态。

请注意以上重点内容的高亮显示。这些是 wait() 和 sleep() 方法之间最重要和区别的方面。

区别wait() 方法sleep() 方法
调用方式在对象上调用在线程上调用
位置要求必须在同步代码块或同步方法中使用可以在任何地方使用
锁释放调用后释放对象的锁，使其他线程可以访问该对象调用时不会释放任何锁
通常用途与 notify() 或 notifyAll() 方法一起实现线程间通信和同步简单的使线程暂停执行一段预定的时间
异常处理需要处理 InterruptedException 异常可能需要处理 InterruptedException 异常，但不常用

这张表格清晰地总结了wait() 和 sleep() 方法之间的区别，包括调用方式、位置要求、锁释放、通常用途和异常处理等方面。

🍁🍁 02、用Java实现阻塞队列？

在 Java 中实现阻塞队列，可以使用 ArrayBlockingQueue 或者 LinkedBlockingQueue。下面我将为你演示如何使用 ArrayBlockingQueue 实现阻塞队列：

首先，你需要导入 java.util.concurrent 包：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

然后，在你的代码中可以这样创建一个阻塞队列：

// 创建一个最大容量为 10 的 ArrayBlockingQueue
BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

接下来，你可以在生产者线程中向队列中添加元素，而在消费者线程中从队列中取出元素。当队列已满时，生产者线程会被阻塞，直到队列有空间为止；当队列为空时，消费者线程会被阻塞，直到队列有元素为止。

下面是一个简单的示例代码：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                int value = 1;
                while (true) {
                    queue.put(value); // 向队列中添加元素，如果队列已满则会阻塞
                    System.out.println("Produced: " + value);
                    value++;
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                while (true) {
                    int value = queue.take(); // 从队列中取出元素，如果队列为空则会阻塞
                    System.out.println("Consumed: " + value);
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

在这个示例中，我们创建了一个容量为 10 的 ArrayBlockingQueue，然后分别创建了生产者线程和消费者线程。生产者线程会不断地往队列中添加元素，而消费者线程会不断地从队列中取出元素。

🍁🍁 03、一个线程运行时发生异常会怎样？

当一个线程运行时发生异常，如果该线程没有合适地处理这个异常，那么以下情况可能会发生：

  1. 异常将终止该线程： 如果线程没有对异常进行处理，那么异常将传播到线程的顶层，触发线程的异常处理机制。在默认情况下，未捕获的异常将导致线程终止。如果该线程是应用程序的主线程，那么整个应用程序可能会崩溃。

  2. 异常信息将会被记录： 未捕获的异常通常会被记录到控制台或日志文件中，以便开发人员排查问题。

  3. 影响其他线程： 如果异常没有得到适当处理，它可能会对应用程序的其他部分产生影响，甚至导致整个应用程序的异常行为。

为了处理线程中发生的异常，可以在线程的 run() 方法中使用 try-catch 块来捕获异常，并在 catch 块中进行异常处理，比如记录日志、释放资源、通知其他模块等。另外，可以通过设置默认的未捕获异常处理器（UncaughtExceptionHandler）来处理未捕获的异常，以便在发生异常时进行统一处理。

总之，在多线程编程中，及时的异常处理对于保证程序的稳定性和可靠性非常重要。

🍁🍁 04、如何在两个线程间共享数据？

在两个线程之间共享数据时，可以使用共享变量或共享对象来实现数据共享。下面我将举一个简单的例子来说明如何在两个线程之间共享数据：

public class DataSharingExample {
    private static int sharedData = 0; // 共享的数据

    public static void main(String[] args) {
        // 线程1对共享数据进行递增操作
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                synchronized (DataSharingExample.class) {
                    sharedData++;
                    System.out.println("Thread 1: Incremented shared data to " + sharedData);
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        // 线程2对共享数据进行递减操作
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                synchronized (DataSharingExample.class) {
                    sharedData--;
                    System.out.println("Thread 2: Decremented shared data to " + sharedData);
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

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

在这个例子中，我们有一个共享的整数 sharedData，其中线程1递增它，线程2递减它。通过使用 synchronized 关键字，我们确保了每个线程在访问共享数据时的互斥性，即每个线程在修改 sharedData 时需要获取锁，防止同时对其进行访问，以避免数据的不一致性或竞态条件。

请注意，上述示例中只是一个简单的示例，为了演示数据共享的概念。在实际的多线程编程中，需要更加谨慎地处理共享数据，考虑线程安全性、避免死锁等问题。此外，还可以使用其他的同步机制，如 Lock 和 Condition，以及使用 volatile 关键字来实现线程之间的数据共享。根据具体的需求和场景选择合适的方法来进行数据共享。

🍁🍁 05、Java中notify和notifyAll有什么区别？

在Java中，notify() 和 notifyAll() 是用于线程间通信的方法，用于唤醒等待在某个对象上的线程。它们的区别如下：

  1. notify(): 当使用 notify() 方法时，它会随机选择一个正在等待该对象锁的线程，并唤醒它。注意，虽然选择是随机的，但不保证哪个线程会被唤醒。其他线程仍然会保持等待状态，直到它们再次获得锁并被唤醒。

  2. notifyAll(): 当使用 notifyAll() 方法时，它会唤醒所有正在等待该对象锁的线程。所有被唤醒的线程将再次进入“竞争状态”，尝试重新获取锁。

因此，notify() 方法只能唤醒一个线程，可能导致其他线程继续等待；而 notifyAll() 方法会唤醒所有等待的线程，它们会再次尝试获取锁并继续执行。

在使用这两个方法时，需要注意以下几点：

  • 调用 notify() 或 notifyAll() 方法的线程必须拥有该对象的锁。
  • 唤醒的线程只有在当前线程释放锁之后，才能继续执行。
  • 被线程会与其他线程竞争锁，因此需要在的地方使用 synchronized 块或锁来确保线程安全性。

在多线程编程中，合理使用 notify() 和 notifyAll() 方法可以很好地控制线程的挂起和唤醒，实现线程之间的协作和同步。

以下是一个通过表格形式详细说明 notify() 和 notifyAll() 之间区别的示例：

区别点notify()notifyAll()
唤醒的线程数量唤醒一个等待中的线程唤醒所有等待中的线程
唤醒哪个线程随机选择等待中的线程唤醒所有等待中的线程
竞争状态被唤醒的线程需要与其他线程竞争锁被唤醒的线程需要与其他线程竞争锁
使用条件当多个线程在同一个对象上等待时，只需唤醒其中任意一个线程即可当多个线程在同一个对象上等待时，需要唤醒所有等待中的线程

希望这个表格能够清楚地展示 notify() 和 notifyAll() 之间的区别。需要注意的是，具体选择在何时使用哪个方法取决于具体的需求和设计。

🍁🍁 06、为什么wait,notify和notifyAll这些方法不在thread类里面？

wait()、notify() 和 notifyAll() 这些方法不在Thread类里面，而是定义在Object类中的原因是因为它们是用于线程间的协作与通信，并不是线程的核心功能。

Object类是Java中所有类的基类，在多线程编程中，每个对象都有一个相关联的监视器锁（也称为内置锁或对象锁）。线程可以通过获取对象的监视器锁来进入同步块，以实现对共享资源的安全访问或线程之间的协作。

同时，wait()、notify() 和 notifyAll() 这些方法的实现是依赖于监视器锁的。wait() 方法会释放对象的锁，并使当前线程进入等待状态，直到其他线程调用该对象上的 notify() 或 notifyAll() 方法来唤醒它。因此，这些方法必须与对象的锁紧密关联。

将这些方法定义在Object类中，而不是Thread类中，是为了让任何一个对象都可以成为线程间通信的对象，而不仅仅是线程本身。这样，不同的线程可以在共享的对象上进行等待和通知，实现更灵活和精细的线程协作。

另外，Java中的线程是独立的实体，Thread类提供了线程的基本操作和管理相关的方法，如创建、启动、停止等。而 wait()、notify() 和 notifyAll() 这些方法属于对象级别的操作，并不直接与线程的创建、启动和停止等操作相关联。因此，将它们定义在与线程无关的Object类中更加符合设计的逻辑。

🍁🍁 07、什么是ThreadLocal变量？

ThreadLocal 是 Java 中的一个类，用于创建线程本地变量。线程本地变量是指每个线程都可以独立访问和修改的变量，不会被其他线程共享。每个使用 ThreadLocal 创建的变量，实际上是存储在该线程的 ThreadLocal Map 中的一个副本。

以下是关于 ThreadLocal 变量的一些要点：

  1. 独立副本： 通过 ThreadLocal 创建的变量，每个线程都拥有自己的一个副本，不与其他线程共享。线程之间的变量操作互相不会干扰，能够实现线程安全。

  2. 初始化： ThreadLocal 变量在每个线程第一次访问时会延迟初始化。可以通过 initialValue() 方法在定义 ThreadLocal 时设置初始值。

  3. 线程范围：ThreadLocal 变量只在当前线程内可见，对其他线程不可见。其他线程无法直接访问另一个线程的 ThreadLocal 变量。

  4. 线程上下文：ThreadLocal 变量常用于在多个方法或组件间传递数据，避免显式参数传递的麻烦。在同一线程的不同方法间可以通过访问相同的 ThreadLocal 变量来共享数据。

  5. **内存泄漏风险：**使用 ThreadLocal 时需要注意内存泄漏的风险。由于变量和线程生命周期有关，如果不进行适当的清理操作，会导致对象无法被回收，从而可能引发内存泄漏。

ThreadLocal 在多线程环境下提供了一种简单而有效的线程隔离机制，常用于解决线程安全问题、跨线程传递数据等场景。但需要注意合理使用，避免滥用 ThreadLocal 导致问题复杂化。

🍁🍁 08、Java中interrupted和isInterrupted方法的区别？

在Java中，interrupted() 和 isInterrupted() 都是用于检测线程的中断状态的方法，但它们有一些差别。

  1. interrupted() 方法：

    • interrupted() 方法是 Thread 类的静态方法，用于检测当前线程是否被中断，并且会清除当前线程的中断状态。
    • 如果调用该方法时，当前线程的中断状态为true，则返回true；否则返回false。
    • 调用 interrupted() 方法后，不论返回结果是true还是false，都会将当前线程的中断状态重置为false。

  2. isInterrupted() 方法：

    • isInterrupted() 方法是 Thread 类的实例方法，用于检测调用该方法的线程的中断状态，但不会改变该线程的中断状态。
    • 如果调用该方法时，线程的中断状态为true，则返回true；否则返回false。

简而言之，interrupted() 方法是静态方法，用于检测并清除当前线程的中断状态，而 isInterrupted() 方法是实例方法，用于检测线程对象的中断状态而不会修改它。

以下是一个简单的示例：

Thread myThread = new Thread(() -> {
    while (!Thread.interrupted()) {
        // 执行任务
    }
    // 执行终止后的操作
});

// 中断线程
myThread.interrupt();

// 检测中断状态
boolean interrupted = Thread.interrupted();  // 返回true，并清除线程的中断状态

boolean isInterrupted = myThread.isInterrupted();  // 返回true，但不会修改线程的中断状态

使用 interrupted() 和 isInterrupted() 方法可以根据线程的中断状态来控制线程的执行以及执行终止后的处理逻辑。

下面是一个表格，说明了 interrupted() 和 isInterrupted() 方法的区别：

区别interrupted() 方法isInterrupted() 方法
是静态方法是否
检测并清除当前线程的中断状态是否
返回结果如果当前线程的中断状态为true，则返回true如果线程的中断状态为true，则返回true
重置当前线程的中断状态为false是无影响

总结一下：

  • interrupted() 是 Thread 类的静态方法，用于检测并清除当前线程的中断状态，并返回中断状态。调用该方法后，无论返回结果是true还是false，都会将当前线程的中断状态重置为false。
  • isInterrupted() 是 Thread 类的实例方法，用于检测线程对象的中断状态，并返回中断状态。调用该方法不会清除中断状态，只是返回中断状态的值。

根据具体的需求，选择使用适合的方法来检测和处理线程的中断状态。

🍁🍁 09、为什么wait和notify方法要在同步块中调用？

在Java中，wait() 和 notify() 方法被用于线程间的通信，用于实现线程的等待和唤醒操作。这两个方法通常在同步块中调用，原因如下：

  1. 对象监视器（锁）的要求：wait() 和 notify() 方法需要获取对象的监视器（锁），而同步块提供了对监视器的自动获取和释放。在同步块中调用这两个方法，确保了正确的获取和释放锁的顺序，避免了竞态条件和线程安全问题。

  2. 确保线程安全： 通过在同步块中调用wait() 和 notify() 方法可以确保在多线程环境下的线程安全性。只有持有同一个对象的锁的线程才能够在同步块中调用 wait() 和 notify() 方法，这样可以避免多个线程同时调用导致的并发问题。

  3. 避免非法调用： 在同步块外调用 wait() 和 notify() 方法将会抛出 IllegalMonitorStateException 异常，因为在调用这两个方法时需要获取对象锁，而不在同步块内意味着没有正确获取锁进行操作。

示例代码如下所示：

Object lock = new Object();

// 线程A：等待并释放锁
synchronized (lock) {
    while (!条件满足) {
        lock.wait();  // 在同步块内调用wait方法
    }
    // 执行操作
}

// 线程B：唤醒线程A
synchronized (lock) {
    lock.notify();  // 在同步块内调用notify方法
}

总结：为了保证线程的安全性并正确使用wait() 和 notify() 方法，它们应该在同步块内部调用，以确保对监视器的正确操作和锁的获取与释放。这样可以避免并发问题和非法调用异常。

🍁🍁 10、为什么你应该在循环中检查等待条件?

在Java多线程编程中，使用wait()方法等待线程的唤醒时，需要在一个while循环内检查等待条件，而不是使用if语句。

原因如下：

  1. 检查条件是否发生变化： 等待条件可能在接下来的处理过程中发生变化，如果使用if语句进行条件检查的话，唤醒后直接执行程序，没有再次检查等待条件的机会，可能会导致程序出现逻辑错误。而使用循环检查条件，则可以确保再次唤醒后再次检查等待条件，确保逻辑正确性。

  2. 避免虚假唤醒： 在多线程编程中，使用wait()方法等待线程的唤醒时，存在虚假唤醒（Spurious Wakeup）的可能性，可能会在没有明确的唤醒信号的情况下唤醒线程。如果在if语句中判断是否被唤醒，可能在没有明确的唤醒信号的情况下错误地理解线程已被唤醒。而使用循环检查条件，则可以避免虚假唤醒带来的误判。

因此，正确的使用wait()方法等待线程唤醒时，需要在一个while循环内检查等待条件，不断进行条件检查。示例代码如下所示：

synchronized (lock) {
    while (!condition) {
        lock.wait();
    }
    // 条件已经满足，执行相应的操作
}

总结：在使用wait()方法等待线程的唤醒时需要在一个循环内检查等待条件，以避免虚假唤醒和检查等待条件的变化。

🍁🍁 11、Java中的同步集合与并发集合有什么区别？

Java中的同步集合和并发集合都是用于在多线程环境中处理共享数据的集合类，但它们有以下区别：

  1. 同步性质： 同步集合是通过同步机制来保证线程安全的，它使用内部锁（互斥锁）来确保在同一时间只有一个线程能够修改集合。而并发集合则是通过使用特定的数据结构和算法来实现线程安全，它更多地采用了无锁（lock-free）或者低锁（lock-striping）策略，以提高并发性能。

  2. 性能： 由于同步集合使用了内部锁机制，所以在多线程环境下，不同线程之间需要进行竞争获取锁的操作，这可能会导致线程的等待和上下文切换，从而降低性能。而并发集合使用了无锁或低锁策略，减少了锁竞争的开销，可以提供更好的并发性能。

  3. 迭代器支持： 在同步集合中，如果一个线程在迭代集合的同时，另一个线程对集合进行修改，将会抛出ConcurrentModificationException异常。而在并发集合中，可以通过特定的迭代器（如ConcurrentHashMap中的ConcurrentHashMap.KeySetView）支持并发修改和迭代操作。

  4. 功能和多样性： 并发集合提供了一系列更加丰富的功能，如ConcurrentHashMap、CopyOnWriteArrayList等，它们针对不同的应用场景提供了针对性的解决方案。而同步集合相对简单，提供的功能相对较少。

基于以上的区别，选择适合的集合类需要根据实际需求。如果需要线程安全而不关心性能问题，可以选择同步集合；如果需要高并发性能和更多的功能，可以选择并发集合。

以下是同步集合和并发集合在几个方面的区别的表格说明：

方面同步集合并发集合
同步性质使用内部锁（互斥锁）实现线程安全使用无锁或低锁策略实现线程安全
性能可能存在锁竞争和上下文切换，性能较低减少锁竞争开销，提供更好的并发性能
迭代器支持迭代过程中被修改会抛出 ConcurrentModificationException 异常支持并发修改和迭代操作
功能和多样性提供的功能相对简单提供更多丰富的功能和针对性的解决方案
使用场景单线程或少量线程环境，对线程安全要求较高高并发多线程环境，对性能要求较高且需要更多功能

需要根据具体的需求和场景来选择合适的集合类，权衡线程安全性、性能以及功能的需求。

🍁🍁 12、什么是线程池？为什么要使用它？

线程池是一种线程管理的机制，它可以在程序启动时创建一定数量的线程并维持一个线程池。当需要线程时，可以从线程池中获取空闲线程，执行任务后归还线程池。线程池可以管理和减少线程的创建和销毁开销，提高程序的性能和效率。

使用线程池有以下好处：

  1. 降低线程的创建和销毁开销： 线程的创建和销毁是比较昂贵的操作，如果每次任务都要创建一个新的线程，会占用大量的系统资源，而线程池可以通过预先创建并保存一定数量程并重复利用它们，降低这些开销。

  2. 提高系统的稳定性： 线程池能够限制并发线程数量，防止线程数量过多导致系统资源耗尽。同时也能够设置任务队列，对任务进行排队和调度，避免系统过载。

  3. 提高程序的响应速度： 对于一些需要频繁创建和销毁线程的任务，使用线程池可以大大减少线程的创建和销毁开销，从而提高程序的响应速度。

  4. 方便管理和监控线程： 线程池可以方便地管理和监控线程的运行状况，如设置线程池大小、线程超时时间、错误处理等等。

综上所述，使用线程池可以优化程序的性能和效率，并提高系统的稳定性和可维护性。

🍁🍁 13、怎么检测一个线程是否拥有锁？

要检测线程是否拥有锁，需要在获取锁时记录下当前获取锁的线程信息，然后在需要检测时获取锁的线程信息并比对即可。具体实现可以借助 Java 中的 ReentrantLock 或者 synchronized 关键字来实现。

以 ReentrantLock 为例，在获取锁时通过 getOwner() 方法获取当前获取锁的线程信息，然后在需要检测时调用 isHeldByCurrentThread() 方法，比对当前线程是否为获取锁的线程。示例代码如下：

ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    Thread thread = Thread.currentThread();
    if (lock.isHeldByCurrentThread()) {
        System.out.println("当前线程 " + thread.getName() + " 持有锁");
    } else {
        System.out.println("当前线程 " + thread.getName() + " 未持有锁");
    }
} finally {
    lock.unlock();
}

使用 synchronized 关键字时，需要在获取锁时记录下锁对象，然后在需要检测时比对锁对象的持有者是否为当前线程。示例代码如下：

Object lock = new Object();
synchronized (lock) {
    Thread thread = Thread.currentThread();
    if (Thread.holdsLock(lock)) {
        System.out.println("当前线程 " + thread.getName() + " 持有锁");
    } else {
        System.out.println("当前线程 " + thread.getName() + " 未持有锁");
    }
}

需要注意的是，线程可能存在多重锁嵌套的情况，因此在检测时需要考虑所有锁对象的持有者。

🍁🍁 14、你如何在Java中获取线程堆栈？

在Java中，可以通过以下两种方式之一获取线程的堆栈信息：

1. 使用Thread.currentThread().getStackTrace()方法：

StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();

这将返回一个StackTraceElement数组，其中包含了当前线程的堆栈信息。

2. 使用Thread.getAllStackTraces()方法：

Map<Thread, StackTraceElement[]> stackTraces = Thread.getAllStackTraces();

这将返回一个包含所有线程堆栈信息的Map对象，其中键是线程，值是对应线程的堆栈信息数组。

对于上述两种方法，可以通过遍历StackTraceElement数组或Map对象，获得每个堆栈元素的相关信息，如类名、方法名、文件名等。

例如，以下是一个简单的示例，展示如何获取当前线程的堆栈信息并打印出来：

StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
for (StackTraceElement element : stackTrace) {
    System.out.println(element.getClassName() + " - " +
                       element.getMethodName() + " - " +
                       element.getFileName() + " - " +
                       element.getLineNumber());
}

需要注意的是，获取线程堆栈信息可能会对性能产生一定的影响，因此在实际应用中需要根据需要进行使用。另外，Java还提供了一些其他的调试工具和API来获取线程堆栈信息，如使用jstack命令行工具，或者使用Java Management Extensions (JMX) API等。

🍁🍁 16、Thread类中的yield方法有什么作用？

yield 方法的作用是让当前线程暂停执行，并释放锁，然后让其他线程有机会执行。当线程再次获得执行权时，会从 yield 语句之后继续执行。

Thread类中的yield()方法用于暂停当前正在执行的线程，让其他具有相同优先级的线程有机会执行。它的作用是让出CPU资源，让其他线程有更多的执行时间。

当一个线程调用yield()方法时，它会进入就绪状态，然后让操作系统重新调度线程，从而可能使其他的线程获得执行的机会。但是，并不能保证yield()方法一定会让出CPU资源，它只是提供了一种提示给操作系统的机制。

这个方法在某些特定的情况下可以用来优化线程的执行顺序，如在某个线程上执行密集计算的任务时可以在一些时间点上调用yield()方法，使其他线程有机会执行，从而避免某个线程长时间占用CPU资源而导致其他线程无法执行。但需要注意的是，过度使用yield()方法可能会导致线程过于频繁地切换，从而带来一定的性能损失。

总的来说，yield()方法的作用是在特定情况下提供了一种线程调度的提示，让其他线程能有更多的执行机会。但在一般情况下，应该避免过度使用yield()方法，而是倾向于使用更加可控和精确的方式来进行线程调度和协作。

# 示例代码
import threading

def task1():
    for i in range(5):
        print('task1:', i)
        yield

def task2():
    for i in range(5):
        print('task2:', i)
        yield

t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)

t1.start()
t2.start()

t1.join()
t2.join()

输出结果：
task1: 0
task2: 0
task1: 1
task2: 1
task1: 2
task2: 2
task1: 3
task2: 3
task1: 4
task2: 4

可以看到，两个线程交替执行，并且每个线程都执行了 5 次。

🍁🍁 17、Java中ConcurrentHashMap的并发度是什么？

ConcurrentHashMap是Java中提供的线程安全的HashMap实现，它支持高效并发地对键值对进行读写操作。而ConcurrentHashMap的并发度就是它内部实现的一个重要参数，用于控制对HashMap的并发访问操作。

具体来说，并发度是ConcurrentHashMap中的一个整数，它表示HashMap底层的存储桶(bucket)的数量。在ConcurrentHashMap内部，为了支持高效的并发操作，其将底层数据结构分成了多个存储桶，每个存储桶内部都可以独立地进行读写操作，从而可以提高HashMap的并发性和吞吐量。

在对ConcurrentHashMap进行初始化时，可以通过指定一个并发度来控制HashMap中存储桶的数量。默认情况下，并发度是16，也就是说，ConcurrentHashMap中有16个独立的存储桶可以并行地进行读写操作。可以通过如下代码进行初始化：

ConcurrentMap<Key, Value> map = new ConcurrentHashMap<>(16);

需要注意的是，并发度不是越大越好。如果并发度设置过大，会导致每次访问时需要竞争更多的存储桶，从而可能会降低并发性能。因此，在实际使用中，需要结合具体的应用场景和系统配置来确定并发度的合适值。

🍁🍁 18、Java中Semaphore是什么？

在Java中，Semaphore（信号量）是一种同步器，用于控制对资源的并发访问。它是一种计数信号，用于限制对共享资源的并发访问数量。

Semaphore维护了一个许可数量，线程在请求访问资源之前需要先获取许可（acquire），而使用完资源之后需要释放许可（release）。当Semaphore的许可数量为正数时，线程可以获取许可并继续执行；当许可数量为零时，线程需要等待，直到有其他线程释放许可。

Semaphore常用于限制对一组有限资源的并发访问，例如数据库的连接池、线程池、读写锁等。通过合理地控制许可数量，可以限制并发访问的线程数量，从而避免资源过度竞争和消耗。

在Java中，Semaphore类是java.util.concurrent包提供的一个实现。它提供了以下常用的方法：

  • acquire(): 获取一个许可，若没有许可则阻塞线程
  • acquire(int permits): 获取指定数量的许可
  • release(): 释放一个许可
  • release(int permits): 释放指定数量的许可
  • getQueueLength(): 获取等待许可的线程数量

Semaphore的使用需要注意合理地分配许可数量，避免死锁和饥饿等问题。同时，使用Semaphore也要注意多线程并发访问资源时的线程安全性。

Semaphore 是一个计数信号量，它可以用来控制同时访问某些资源的线程数。Semaphore 有两个操作：acquire() 和 release()。acquire() 方法会使计数器减 1，如果计数器为 0，则当前线程会被阻塞，直到其他线程调用 release() 方法将计数器加 1。release() 方法会使计数器加 1，如果有线程被阻塞，则会唤醒其中一个线程。

Semaphore 可以用来实现互斥访问，也可以用来实现线程同步。

下面是一个简单的例子，使用 Semaphore 实现互斥访问：

public class SemaphoreDemo {

    private static final int THREAD_COUNT = 10;

    private static final Semaphore semaphore = new Semaphore(1);

    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("Thread " + Thread.currentThread().getName() + " acquired the semaphore");
                    Thread.sleep(1000);
                    System.out.println("Thread " + Thread.currentThread().getName() + " released the semaphore");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }).start();
        }
    }
}

运行这个程序，我们会看到如下输出：

Thread 0 acquired the semaphore
Thread 1 acquired the semaphore
Thread 2 acquired the semaphore
Thread 3 acquired the semaphore
Thread 4 acquired the semaphore
Thread 5 acquired the semaphore
Thread 6 acquired the semaphore
Thread 7 acquired the semaphore
Thread 8 acquired the semaphore
Thread 9 acquired the semaphore
Thread 0 released the semaphore
Thread 1 released the semaphore
Thread 2 released the semaphore
Thread 3 released the semaphore
Thread 4 released the semaphore
Thread 5 released the semaphore
Thread 6 released the semaphore
Thread 7 released the semaphore
Thread 8 released the semaphore
Thread 9 released the semaphore

可以看到，每个线程都成功获取了 Semaphore，并且在执行完毕后释放了 Semaphore。

Semaphore 也可以用来实现线程同步。下面是一个简单的例子，使用 Semaphore 实现线程同步：

public class SemaphoreDemo {

    private static final int THREAD_COUNT = 10;

    private static final Semaphore semaphore = new Semaphore(1);

    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println("Thread " + Thread.currentThread().getName() + " acquired the semaphore");
                    Thread.sleep(1000);
                    System.out.println("Thread " + Thread.currentThread().getName() + " released the semaphore");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }).start();
        }

        try {
            semaphore.acquire();
            System.out.println("Main thread acquired the semaphore");
            Thread.sleep(1000);
            System.out.println("Main thread released the semaphore");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

运行这个程序，我们会看到如下输出：

Thread 0 acquired the semaphore
Thread 1 acquired the semaphore
Thread 2 acquired the semaphore
Thread 3 acquired the semaphore
Thread 4 acquired the semaphore
Thread 5 acquired the semaphore
Thread 6 acquired the semaphore
Thread 7 acquired the semaphore
Thread 8 acquired the semaphore
Thread 9 acquired the semaphore
Main thread acquired the semaphore
Thread 0 released the semaphore
Thread 1 released the semaphore
Thread 2 released the semaphore
Thread 3 released the semaphore
Thread 4 released the semaphore
Thread 5 released the semaphore
Thread 6 released the semaphore
Thread 7 released the semaphore
Thread 8 released the semaphore

🍁🍁 19、什么是阻塞式方法？

阻塞式方法是指在调用该方法时，如果满足某些条件或者发生某些情况，方法会暂时阻塞（挂起）当前线程，直到满足特定条件后才会继续执行或返回结果。

阻塞式方法常用于需要等待外部事件或条件满足的情况下，以保证线程的安全性和资源的正确使用。例如，输入输出操作（I/O）、线程同步、网络请求等都可能涉及阻塞式方法的使用。

在调用阻塞式方法时，线程会进入阻塞状态，暂时释放CPU资源，直到满足特定条件后才能继续执行。这种方式可以避免忙等待（busy waiting），节省CPU资源的使用，提高系统的效率。

阻塞式方法的一般特点包括：

  • 阻塞调用：调用方法后，当前线程会被阻塞（挂起），等待某个条件或事件的发生。
  • 释放资源：阻塞式方法一般会释放当前线程所持有的锁或其他资源，以允许其他线程对资源进行访问。
  • 阻塞原因：阻塞式方法被阻塞的原因可能是等待I/O完成、等待其他线程通知、等待锁释放等。

需要注意的是，阻塞式方法的使用需要结合具体的场景和需求，合理地进行代码设计和资源管理，以避免死锁、饥饿等问题，并确保系统的正确性和性能。

🍁🍁 20、Java线程池中submit()和execute()方法有什么区别？

在Java线程池中，submit()和execute()方法都可以用于提交任务给线程池执行，但它们有以下几点区别：

  1. 返回值类型：submit()方法返回一个Future对象，可以通过该对象获取任务执行的结果或取消任务；而execute()方法没有返回值。

  2. 异常处理：submit()方法可以捕获任务执行过程中的异常，可以通过Future对象的get()方法获取异常信息；而execute()方法无法获取任务执行过程中的异常。

  3. 任务类型：submit()方法接受Runnable和Callable两种类型的任务，即可以接受没有返回值的任务（Runnable），也可以接受有返回值的任务（Callable）；而execute()方法只接受Runnable类型的任务。

  4. 扩展性：submit()方法更加灵活，可以将任务执行结果通过Future对象进行处理，还可以处理任务执行的异常；而execute()方法更加简洁，适用于不需要关心任务执行结果和异常的场景。

综上所述，使用submit()方法更加灵活，并且更适合需要关心任务执行结果和异常处理的情况；而execute()方法更加简洁，适用于不需要关心任务执行结果和异常的场景。根据具体的需求和场景选择使用适合的方法。

区别submit()方法execute()方法
返回值类型返回Future对象无返回值
异常处理可以捕获任务执行过程中的异常无法获取任务执行过程中的异常
任务类型可接受Runnable和Callable类型的任务只接受Runnable类型的任务
扩展性更加灵活，可以处理任务执行结果和异常简洁，不需要关心任务执行结果和异常

在上述表格中，对submit()方法和execute()方法的区别进行了概括总结。可以通过比较不同方面的特性来选择适合的方法。

下面是一个简单的Java程序，通过线程池中的submit()和execute()方法分别提交任务，同时演示了它们的区别和用法：

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        Callable<String> taskCallable = () -> {
            Thread.sleep(3000);
            return "任务执行完成。";
        };

        Runnable taskRunnable = () -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务执行完成。");
        };

        Future<String> future1 = executorService.submit(taskCallable);
        System.out.println(future1.get());
        
        Future<String> future2 = executorService.submit(taskCallable);
        System.out.println(future2.get());

        executorService.execute(taskRunnable);
        executorService.execute(taskRunnable);

        executorService.shutdown();
    }
}

在上述代码中，首先定义了一个线程池，通过Executors.newFixedThreadPool(2)方法创建。然后分别定义了一个Callable类型的任务和一个Runnable类型的任务，这两个任务都需要执行3秒钟。

接着利用submit()方法提交两个Callable类型的任务给线程池执行，并通过Future对象的get()方法获取任务执行的结果。因为提交的是Callable类型的任务，所以通过Future对象可以获取任务执行的结果。

然后再利用execute()方法提交两个Runnable类型的任务给线程池执行，因为提交的是Runnable类型的任务，所以无法获取任务执行的结果。

最后，调用线程池的shutdown()方法来关闭线程池。

可以看出，submit()方法和execute()方法的用法非常相似，但是它们在提交任务的类型和获取任务执行结果方面存在一些区别。

在这里插入图片描述

文章来源:https://blog.csdn.net/m0_50308467/article/details/135301948
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
最新文章