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

发布时间：2023年12月27日

在这里插入图片描述

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

并发编程知识专栏学习

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

文章目录

🏆 初识Java并发编程

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

🍁🍁 01、线程与进程的区别？

线程与进程的区别在于它们所表示的执行单元和共享资源的范围不同。

  • 进程 是操作系统进行资源分配和调度的基本单位，具有独立的内存空间和系统资源，包括独立的地址空间、独立的文件描述符、独立的堆栈等。每个进程都拥有独立的内存空间，因此进程间的通信需要额外的机制来实现，比如管道、消息队列、共享内存等。

  • 线程 是操作系统调度的基本单位，是进程中的执行单元。一个进程中的多个线程共享相同的地址空间和系统资源，包括共享的地址空间、共享的文件描述符、共享的堆栈等。线程之间可以通过共享内存等机制来进行通信，因此线程间的通信相对于进程间的通信更加高效。

因此，重点区别在于进程拥有独立的资源和地址空间，而线程则共享所属进程的资源和地址空间。这也意味着创建和上下文切换一个线程比创建和上下文切换一个进程要快得多，同时线程间的通信和数据共享更为简便。

下面是一个表格，说明了线程与进程的区别。

区别进程线程
资源拥有独立的资源，包括内存、文件描述符等共享所属进程的资源
地址空间拥有独立的地址空间共享所属进程的地址空间
创建创建进程较慢创建线程较快
上下文切换上下文切换代价较高，耗费时间和开销较大上下文切换代价较低，效率较高
通信进程间通信需要额外的机制，如管道、消息队列、共享内存等线程间通信更加直接简便，可以直接读写共享变量
执行单元拥有独立的执行单元，可以独立执行任务作为进程的执行单元，共享同一个进程的资源

总结来说，进程和线程的主要区别在于资源、地址空间、创建、上下文切换、通信和执行单元等方面。进程拥有独立的资源和地址空间，创建和上下文切换较慢，通信需要额外的机制，可以独立执行任务；而线程共享所属进程的资源和地址空间，创建和上下文切换较快，通信更加直接简便，作为进程的执行单元而存在。

🍁🍁 02、在java中守护线程和本地线程区别？

在 Java 中，守护线程（Daemon Thread）和本地线程（Native Thread）是两个不同的概念，它们的区别如下：

  1. 守护线程（Daemon Thread）：

    • 守护线程是一种特殊的线程，它的作用是为其他线程提供便利服务。
    • 当所有的非守护线程都执行完毕时，无论守护线程是否执行完毕，JVM 都会自动退出。因此，守护线程的生命周期取决于是否还有非守护线程在运行。
    • 在 Java 中可以通过 setDaemon(true) 方法将线程设置为守护线程。通常守护线程用于执行一些后台任务，比如垃圾回收器、JVM 的内部维护线程等。

  2. 本地线程（Native Thread）：

    • 本地线程是指由操作系统直接管理和调度的线程。
    • 在 Java 中，线程一般是由 JVM 进行管理和调度的，称为虚拟机线程（Virtual Thread）。而本地线程则是由操作系统管理的，称为本地线程。
    • 从 Java 1.2 开始，Java 的线程模型已经与操作系统的本地线程模型融合了，但是在 Java 中我们通常不会直接操作本地线程，因为 Java 提供了高度抽象的线程模型来隐藏底层的实现细节。

因此，守护线程和本地线程是两个不同的概念：守护线程是一种特殊用途的线程，用于为其他线程提供便利服务；而本地线程则是由操作系统直接管理和调度的线程，与 Java 的线程模型有所区别。

下面是一个表格，说明了守护线程和本地线程的区别：

区别守护线程本地线程
作用为其他线程提供便利服务由操作系统直接管理和调度
生命周期取决于是否还有非守护线程在运行，当所有非守护线程执行完毕时，无论守护线程是否执行完毕，JVM 都会自动退出由操作系统管理，与 Java 的线程模型有所区别
设置方法通过 setDaemon(true) 方法将线程设置为守护线程N/A
示例后台运行的垃圾回收器、JVM 的内部维护线程等由操作系统管理的底层线程，Java 通常不直接操作本地线程
接口实现了 Thread 类的子类或者 Runnable 接口的线程都可以设置为守护线程N/A

总结来说，守护线程和本地线程的区别主要在于作用、生命周期、设置方法、示例和接口等方面。守护线程为其他线程提供便利服务，其生命周期取决于是否还有非守护线程在运行；本地线程由操作系统直接管理和调度，与 Java 的线程模型有所区别，通常不直接操作本地线程。守护线程可以通过 setDaemon(true) 方法进行设置，而本地线程不需要特殊的设置方法。在实际应用中，守护线程常用于执行后台任务，如垃圾回收器、JVM 的内部维护线程等；而本地线程是由操作系统管理的底层线程，Java 通常不直接操作本地线程。

当涉及到守护线程和本地线程时，需要说明的是，Java 中并没有提供直接操作本地线程的接口，因此无法直接演示本地线程的例子。本地线程是由操作系统直接管理和调度的，而 Java 的线程模型通常隐藏了底层的实现细节，因此直接操作本地线程对于普通的 Java 应用来说通常是不必要的。

关于守护线程，我们可以举一个简单的例子来说明守护线程的特点：

public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("Daemon thread is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        daemonThread.setDaemon(true); // 设置为守护线程
        daemonThread.start(); // 启动线程

        // 主线程休眠一段时间
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread finished");
    }
}

在上面的例子中，我们创建了一个守护线程，该守护线程会不断地输出信息。在主线程中，我们让主线程休眠5秒钟，然后输出"Main thread finished"。运行这段代码后，你会发现当主线程结束时，即使守护线程还未执行完毕，JVM 也会自动退出程序。

这个例子展示了守护线程的特点：它的生命周期取决于是否还有非守护线程在运行，当所有非守护线程执行完毕时，无论守护线程是否执行完毕，JVM 都会自动退出。

🍁🍁 03、什么是多线程中的上下文切换？

在多线程编程中，上下文切换是指操作系统在执行多个线程时，需要进行线程之间的切换。当一个线程需要让出 CPU 控制权，让其他线程执行时，操作系统会保存当前线程的上下文信息（如寄存器状态、程序计数器等），将控制权切换给下一个要执行的线程，并加载其上下文信息，使其能够继续执行。

上下文切换是通过操作系统内核实现的，具体实现方式因操作系统而异。

当线程被切换时，操作系统需要保存和恢复线程的状态信息，这会引入一定的开销，包括保存和恢复寄存器、更新线程的上下文、清空和重填 CPU 缓存等。上下文切换频繁发生时，会导致系统性能下降。

上下文切换的发生情况主要有以下几个方面：

  1. 时间片耗尽： 操作系统采用时间片轮转调度算法时，每个线程被分配一定的时间片，在耗尽时间片后，发生上下文切换。
  2. 阻塞和唤醒： 线程由于等待某些事件的发生而被阻塞，当事件发生时，线程被唤醒并发生上下文切换。
  3. 优先级调度： 高优先级的线程抢占了 CPU 控制权，导致低优先级线程发生上下文切换。
  4. 多核处理器间的调度： 如果系统中有多个物理处理器核心，操作系统可能会将线程分配给不同的核心执行，这也会引发上下文切换。

上下文切换是多线程并发执行中不可避免的一部分，合理使用线程和调度算法可以降低上下文切换的开销，提高系统的性能。

🍁🍁 04、什么是线程组，为什么在Java中不推荐使用？

线程组（ThreadGroup）是 Java 中的一个概念，用于将多个线程组织到一个单元中。线程组可以包含其他线程组，因此可以构成一个树状的层次结构。线程组可以方便地对一组线程进行集中管理，例如统一进行异常处理、统一设置线程优先级等。

然而，在 Java 中，线程组并不被推荐使用，主要有以下几个原因：

  1. 灵活性受限： 线程组的设计并未提供足够的灵活性，它并不能完全满足各种复杂的线程管理需求。在大多数情况下，使用更加灵活的 Executor 框架或者线程池能够更好地满足实际需求。

  2. 安全性问题： 线程组提供了stop()和suspend()等方法，这些方法在使用不当时可能导致死锁、状态不一致等严重问题，因此容易出现安全性问题。

  3. 可移植性： 线程组的功能并不稳定，且不同的 Java 虚拟机实现可能对线程组的支持不同，这使得线程组在不同的环境下表现不一致，降低了代码的可移植性。

  4. 已被废弃： 在 Java 9 中，已经把ThreadGroup的一些方法标记为deprecated，这表明 Java 官方已经不推荐继续使用线程组来进行线程管理。

因此，虽然线程组在概念上提供了一种组织线程的方式，但由于上述种种原因，Java 中并不推荐使用线程组。相反，更好的替代方案是使用 Executor 框架提供的线程池，它提供了更加灵活和安全的线程管理机制。

🍁🍁 05、死锁与活锁的区别，死锁与饥饿的区别？

死锁和活锁是多线程编程中的两种常见问题，它们都可能导致线程无法继续执行。下面是它们的区别：

死锁（Deadlock）：

  • 死锁是指两个或多个线程在互相等待对方释放资源，但是又不主动释放自己所持有的资源，导致彼此陷入无限等待的状态。
  • 死锁的场景通常涉及多个线程和多个共享资源，发生死锁时，这些线程都无法继续执行，无法进行进一步的进展。
  • 死锁是一种严重的问题，需要通过合理的资源分配和避免循环等待等策略进行预防和解决。

活锁（Livelock）：

  • 活锁是指线程虽然不被阻塞，但是它们却无法继续执行，因为它们一直在响应其他线程的动作而无法顺利完成自己的工作。
  • 活锁通常发生在多个线程试图解决同一问题时，它们的行为会反复地受到对方的影响，导致彼此都无法顺利地完成任务。
  • 活锁是一种非常棘手的问题，因为线程并没有被真正地阻塞，常规的锁机制无法解决活锁问题，需要使用其他策略来解决，如引入随机性，使得线程有机会继续执行。

死锁和饥饿的区别：

死锁（Deadlock）：

  • 死锁是指多个线程因为相互等待对方持有的资源而无法继续执行，彼此陷入无限等待的状态。
  • 死锁通常发生在资源的互斥使用、持有和等待等条件同时满足时。
  • 死锁是多线程编程中的一种问题，需要采取预防和解决措施。

饥饿（Starvation）：

  • 饥饿是指线程因为长时间得不到所需的资源或得不到执行的机会而无法继续执行，导致无法完成任务或响应其他线程的请求。
  • 饥饿通常是由不公平的资源分配或线程优先级设置不当等原因引起的。
  • 饥饿是一种相对于死锁更宽泛的概念，它描述了线程无法获得所需资源或执行机会的情况，但并不一定导致线程无法执行。

总结：
死锁和活锁都可能导致线程无法继续执行，但死锁是多个线程之间互相等待对方释放资源，而活锁是线程由于相互影响而无法顺利执行。饥饿是指线程无法获得所需资源或执行机会的情况，不一定会导致线程无法执行。

下面是表格说明死锁和活锁的区别：

区别死锁活锁
定义两个或多个线程相互等待对方释放资源线程无法顺利执行，因为相互影响无法达成进展
状态线程处于无限等待状态线程没有被阻塞，但无法顺利执行
原因循环等待资源线程反复响应其他线程的动作
问题严重程度导致线程无法继续执行，需要手动解除死锁导致线程无法顺利执行任务，需要特殊策略解决
解决方法通过资源分配和避免循环等待等策略进行预防和解决引入随机性、优先级设置等策略，使线程有机会继续执行任务
特点资源被占用且无法释放线程持续地相互影响，无法进展
区别死锁饥饿
定义两个或多个线程相互等待对方释放资源线程长时间得不到所需的资源或执行机会
原因循环等待资源资源分配不公平或线程优先级设置不当
影响彼此无法继续执行，造成系统假死线程无法完成任务或响应其他线程的请求
解决方法通过资源分配和避免循环等待等策略进行预防和解决调整资源分配策略或优化线程优先级
资源占用情况资源被占用且互相等待资源被某些线程长时间占用

这些表格展示了死锁和活锁的定义、状态、原因、解决方法和其他一些特点的区别，以及死锁和饥饿的定义、原因、解决方法和对线程执行的影响的区别。

🍁🍁 06、Java中用到的线程调度算法是什么？

在 Java 中，线程调度是通过操作系统来完成的，Java 虚拟机并不直接管理线程的调度。因此，Java 中使用的线程调度算法取决于底层操作系统的调度算法。

常见的操作系统线程调度算法包括：

  1. 先来先服务调度（First Come First Served, FCFS）： 按照线程到达的先后顺序进行调度，先到达的线程先执行。

  2. 时间片轮转调度（Round Robin）： 每个线程被分配一个时间片，当时间片结束后，切换到下一个线程执行，直到所有线程都执行完毕。

  3. 优先级调度（Priority Scheduling）： 根据线程的优先级来进行调度，优先级高的线程先执行，可以是静态优先级或动态优先级。

  4. 多级反馈队列调度（Multilevel Feedback Queue Scheduling）： 根据线程的历史行为和优先级将线程分配到不同的队列中，并根据队列的特定调度算法进行调度。

在 Java 中，可以使用 Thread.setPriority() 方法设置线程的优先级，但最终的调度行为仍受底层操作系统调度算法的影响。因此，Java 中使用的线程调度算法取决于具体的操作系统和 JVM 实现。

🍁🍁 07、为什么使用Executor框架？

使用Executor框架可以带来以下好处：

  1. 简化线程管理：Executor框架提供了高级的线程管理功能，可以帮助我们更方便地创建、启动、停止和管理线程，避免手动处理线程的生命周期和资源释放等问题。

  2. 提高性能：Executor框架可以根据实际需求线程池中保持一定数量的线程，避免线程的频繁创建和销毁，从而减少了线程创建和上下文切换的开销，提高了性能。

  3. 控制资源使用：Executor框架提供了线程池的管理机制，可以限制最大并发线程数，控制任务提交速率，避免资源过度占用，从而更好地利用系统资源。

  4. 提供线程复用：Executor框架中的线程池可以让多个任务共享线程，使得线程可以被复用，减少线程创建和销毁的开销。

  5. 支持异步编程：Executor框架中提供了异步执行任务的功能，可以通过Future或CompletionService等机制获取异步任务的执行结果，使得程序可以并发执行多个任务，提高效率和响应性。

  6. 提供灵活的任务调度：Executor框架中的ScheduledExecutorService可以实现定时调度和周期性执行任务，能够满足定时任务和定期任务的需求。

总结起来，使用Executor框架可以简化线程管理、提高性能、控制资源使用、提供线程复用、支持异步编程和灵活的任务调度。这些优势使得Executor框架成为了Java并发编程中不可或缺的工具之一，并帮助开发人员更加方便地编写高效的多线程应用程序。

🍁🍁 08、在Java中Executor和Executors的区别？

在Java中，Executor和Executors是两个相关的类，它们的主要区别如下：

  1. Executor：Executor是一个接口，定义了异步执行任务的执行器的基本协议。它提供了一种将任务提交和任务执行进行分离的机制，通过使用Executor可以将任务的提交与任务的执行进行解耦，使得系统更加灵活和可维护。Executor接口的核心方法是execute(Runnable task)，用于提交一个Runnable任务给执行器执行。

  2. Executors：Executors是一个包含一些静态工厂方法的类，用于创建常见的ExecutorService实例。它提供了一些方便的方法来创建线程池，隐藏了线程池的创建和配置细节，简化了线程池的使用。Executors类提供的一些常见的方法包括newFixedThreadPool(int nThreads)、newCachedThreadPool()、newSingleThreadExecutor()等，用于创建不同类型的线程池。

总结起来，Executor是一个接口，定义了异步执行任务的基本协议；而Executors是一个工具类，提供了一些方便的静态工厂方法来创建常见的ExecutorService实例。通过Executor接口和Executors类的组合使用，我们可以更方便地进行任务的提交和执行，并利用线程池进行线程管理和资源控制。

下面用表格简单说明一下两者的区别如下：

区别ExecutorExecutors
类型接口工具类
主要作用定义异步执行任务的基本协议包含静态工厂方法，用于创建常见的ExecutorService实例
方法主要方法是execute(Runnable task)包含了一些方便的方法来创建不同类型的线程池，如newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor等
功能提供了将任务提交和任务执行进行分离的机制提供了简化线程池创建和配置的方法
使用方式通过实现接口来定义自定义的执行器通过调用静态工厂方法来创建线程池实例

下面是通过代码举例说明Executor和Executors的区别：

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class ExecutorExample {
    public static void main(String[] args) {
        // 使用Executor接口
        Executor executor = new Executor() {
            @Override
            public void execute(Runnable task) {
                // 自定义的执行逻辑
                Thread thread = new Thread(task);
                thread.start();
            }
        };

        // 提交任务给Executor执行
        executor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("Task executed using Executor");
            }
        });

        // 使用Executors工具类
        Executor fixedThreadPool = Executors.newFixedThreadPool(2);
        fixedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("Task executed using Executors - FixedThreadPool");
            }
        });

        Executor cachedThreadPool = Executors.newCachedThreadPool();
        cachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("Task executed using Executors - CachedThreadPool");
            }
        });
    }
}

在上面的代码中，我们首先通过实现Executor接口自定义了一个执行器，然后使用该执行器来执行任务。接下来，我们使用Executors工具类创建了两个不同类型的线程池（FixedThreadPool和CachedThreadPool），并提交任务给它们执行。

通过运行上述代码，你可以看到Task executed using Executor、Task executed using Executors - FixedThreadPool和Task executed using Executors - CachedThreadPool这三行输出，它们分别代表了通过Executor和Executors执行的三个任务。这个例子展示了Executor和Executors的不同用法和功能。

🍁🍁 09、如何在Windows和Linux上查找哪个线程使用的CPU时间最长？

在Windows和Linux上，可以使用以下方式来查找哪个线程使用的CPU时间最长：

在Windows上：

  1. 打开任务管理器（可以通过右键点击任务栏并选择“任务管理器”打开）
  2. 在任务管理器的“进程”或“详细信息”选项卡中，找到你感兴趣的进程
  3. 单击该进程，然后展开“进程”或“详细信息”选项卡中的“CPU”列
  4. 排序该列以查看使用CPU时间最长的线程

在Linux上：

  1. 打开终端
  2. 使用top命令来监视系统状态和进程信息
  3. 在top界面中，按下Shift+H键，按“%CPU”列对线程进行排序
  4. 查找使用CPU时间最长的线程，并记录其线程ID（TID）

使用以上方法，你可以找到在Windows和Linux上使用CPU时间最长的线程。请注意，此方式只显示系统中当前活动的线程，并且需在正确的权限下运行，以获取相应的信息。

🍁🍁 10、什么是原子操作？在JavaConcurrencyAPI中有哪些原子类(atomicclasses)？

原子操作是指在执行过程中不会被中断的操作，要么全部执行成功，要么全部不执行，不会出现部分执行的情况。原子操作通常是不可分割的单个操作，要么完全执行，要么完全不执行，不会被其他操作所干扰。

在并发编程中，原子操作是非常重要的概念，因为当多个线程同时访问共享资源时，如果这些操作不是原子操作，就可能导致数据不一致性和竞争条件问题。因此，使用原子操作可以保证线程安全，避免了多线程环境下的数据竞争和不一致性。

在编程语言和计算机体系结构中，通常会提供原子操作的支持，比如提供原子类型或者原子操作指令来保证特定操作的原子性。常见的原子操作包括原子读-修改-写操作（比如CAS操作）、原子赋值和原子增减操作等。

总之，原子操作是指不可被中断的操作，能够确保在并发环境下的数据一致性和线程安全。

在Java Concurrency API中，提供了以下常用的原子类：

  1. AtomicInteger：一个提供原子操作的整型类。
  2. AtomicLong：一个提供原子操作的长整型类。
  3. AtomicBoolean：一个提供原子操作的布尔类型类。
  4. AtomicIntegerArray：一个提供原子操作的整型数组类。
  5. AtomicLongArray：一个提供原子操作的长整型数组类。
  6. AtomicReference：一个提供原子操作引用类型的类。
  7. AtomicReferenceArray：一个提供原子操作引用类型数组的类。
  8. AtomicStampedReference：一个提供原子的、带有版本号的引用类型类。
  9. AtomicMarkableReference：一个提供原子的、可标记的引用类型类。
  10. AtomicIntegerFieldUpdater：一个原子更新整型字段的类。
  11. AtomicLongFieldUpdater：一个原子更新长整型字段的类。
  12. AtomicReferenceFieldUpdater：一个原子更新引用字段的类。

这些原子类提供了一种线程安全的方式去更新变量或数组的内容，避免了竞争条件和数据不一致性。它们通过使用底层的硬件原子操作（例如CAS操作）来实现原子性，从而保证了并发环境下的数据安全性。

当使用Java Concurrency API中的常用原子类时，可以按照以下样例来进行使用：

  1. AtomicInteger：
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        System.out.println("Initial counter value: " + counter.get());

        // 原子地增加计数器的值
        counter.incrementAndGet();
        System.out.println("Counter value after increment: " + counter.get());

        // 原子地减少计数器的值
        counter.decrementAndGet();
        System.out.println("Counter value after decrement: " + counter.get());

        // 原子地更新计数器的值
        counter.updateAndGet(value -> value * 2);
        System.out.println("Counter value after update: " + counter.get());
    }
}
  1. AtomicBoolean：
import java.util.concurrent.atomic.AtomicBoolean;

public class AtomicExample {
    private static AtomicBoolean flag = new AtomicBoolean(false);

    public static void main(String[] args) {
        System.out.println("Initial value of flag: " + flag.get());

        // 原子地将flag设为true
        flag.set(true);
        System.out.println("Value of flag after set: " + flag.get());

        // 原子地将flag设为false
        flag.compareAndSet(true, false);
        System.out.println("Value of flag after compareAndSet: " + flag.get());
    }
}
  1. AtomicReference：
import java.util.concurrent.atomic.AtomicReference;

public class AtomicExample {
    private static AtomicReference<String> message = new AtomicReference<>("Hello");

    public static void main(String[] args) {
        System.out.println("Initial message: " + message.get());

        // 原子地更新消息
        message.set("Hello, World!");
        System.out.println("Message after set: " + message.get());

        // 原子地比较并设置消息
        boolean isSuccess = message.compareAndSet("Hello, World!", "Hello, WeTab!");
        System.out.println("Message after compareAndSet: " + message.get());
        System.out.println("CompareAndSet operation result: " + isSuccess);
    }
}
  1. AtomicIntegerArray：
import java.util.concurrent.atomic.AtomicIntegerArray;

public class AtomicExample {
    private static AtomicIntegerArray numbers = new AtomicIntegerArray(5);

    public static void main(String[] args) {
        System.out.println("Initial values of numbers:");

        for (int i = 0; i < numbers.length(); i++) {
            System.out.println("Index " + i + ": " + numbers.get(i));
        }

        // 原子地增加索引位置上的值
        numbers.incrementAndGet(2);
        System.out.println("Value at index 2 after increment: " + numbers.get(2));

        // 原子地更新索引位置上的值
        numbers.updateAndGet(3, value -> value * 2);
        System.out.println("Value at index 3 after update: " + numbers.get(3));
    }
}
  1. AtomicLong：
import java.util.concurrent.atomic.AtomicLong;

public class AtomicExample {
    private static AtomicLong value = new AtomicLong(100L);

    public static void main(String[] args) {
        System.out.println("Initial value: " + value.get());

        // 原子地增加值
        value.incrementAndGet();
        System.out.println("Value after increment: " + value.get());

        // 原子地减少值
        value.decrementAndGet();
        System.out.println("Value after decrement: " + value.get());

        // 原子地增加并返回旧值
        System.out.println("Value before getAndAdd: " + value.getAndAdd(50L));
        System.out.println("Value after getAndAdd: " + value.get());
    }
}

这些是Java Concurrency API中常用的原子类的示例用法。您可以根据您的具体需求选择合适的原子类，并使用它们提供的原子操作来执行线程安全的变量修改。这些原子类可帮助您在多线程环境下使用变量时避免竞态条件和数据不一致的问题。

🍁🍁 11、JavaConcurrencyAPI中的Lock接口(Lockinterface)是什么？对比同步它有什么优势？

Lock接口是Java Concurrency API中的一种显式锁机制，它提供了比synchronized关键字更细粒度的线程同步控制。Lock接口的实现类可以用来保护共享资源的状态，确保多线程环境下的线程安全。

与synchronized关键字相比，Lock接口提供了更多的灵活性和功能，具有以下优势：

  1. 可重入性：锁可以被同一个线程多次获取，而不会导致死锁。这意味着在一个线程中可以多次获取该锁，而不会阻塞其他等待获取该锁的线程。

  2. 条件变量：Lock接口提供了Condition对象，可以通过它实现更复杂的线程通信和协调。使用Condition对象，线程可以在满足特定条件之前等待，并在满足条件后被唤醒。

  3. 公平性：Lock接口可以实现公平性，即按照线程请求锁的顺序来获取锁。而synchronized关键字不能保证公平性，可能会导致线程饥饿问题。

  4. 灵活性：相比于synchronized关键字，Lock接口提供了更多灵活的加锁和解锁方式。可以支持尝试获取锁、超时获取锁等操作。

  5. 性能优化：当有多个线程竞争同一资源时，使用Lock接口可以提供更好的性能。它可以减少线程之间的竞争和上下文切换次数，从而提高系统的吞吐量。

总的来说，与synchronized关键字相比，Lock接口提供了更多的功能和灵活性，并且可以帮助解决一些在使用synchronized时可能会遇到的问题。在需要更细粒度的线程同步控制或更复杂的线程通信时，使用Lock接口会更加合适。

🍁🍁 12、什么是Executors框架？

Executors框架是Java中的一个并发编程框架，位于java.util.concurrent包下。它提供了一组用于管理和控制线程执行的工具类和接口，使得开发者可以更方便地实现并发任务的执行和管理。

Executors框架的核心组件是线程池，它是一组预先创建的线程，可用于执行提交给它的任务。通过线程池，我们可以重用线程、控制并发线程的数量，以及管理线程的生命周期。

使用Executors框架，可以在应用程序中更加有效地利用系统资源，同时提高并发任务的执行性能和效率。开发者无需手动管理线程的创建、启动和销毁过程，简化了多线程程序的编写和维护。

Executors框架提供了一系列工具类和接口，如：

  1. Executor接口：定义了执行任务的最基本接口，其实现类（如ThreadPoolExecutor）可用于创建和管理线程池。

  2. ExecutorService接口：扩展了Executor接口，提供了更丰富的任务提交和执行控制方法，以及获取任务执行结果的能力。

  3. ThreadPoolExecutor类：是ExecutorService接口的一个常用实现类，用于创建和管理线程池。可以通过它指定线程池的大小、线程工厂、任务队列等参数来调整线程池的行为。

  4. Executors工厂类：提供了一系列静态方法，用于创建不同类型的线程池，如单线程线程池、固定大小线程池、缓存线程池等。

通过使用Executors框架，开发者可以更加方便地实现并发任务的调度和管理，提高应用的并发性能和可靠性。

🍁🍁 13、什么是阻塞队列？阻塞队列的实现原理是什么？如何使用阻塞队列来实现生产者-消费者模型？

阻塞队列（Blocking Queue）是一种特殊的队列数据结构，在多线程环境下用于实现线程间的数据交换。

与普通队列不同，阻塞队列具有阻塞特性，即当队列为空时，从队列中获取元素的操作会被阻塞；当队列已满时，向队列中添加元素的操作也会被阻塞。

阻塞队列的主要特点如下：

  1. 线程安全：阻塞队列内部会根据具体实现使用同步机制，保证多线程环境下的线程安全性。

  2. 阻塞操作：当从一个空队列中获取元素时，线程会被阻塞，直到队列中有元素可获取。当向一个满队列中添加元素时，线程也会被阻塞，直到队列有空闲位置。

  3. 等待通知机制：当一个线程被阻塞后，只有当另一个线程向队列中添加或者移除元素时，阻塞的线程才会被唤醒。

阻塞队列的使用场景包括生产者消费者模式、线程池等。在生产者消费者模式中，生产者可以将数据放入阻塞队列，而消费者可以从队列中获取数据，实现线程间的数据交换和解耦。在线程池中，任务可以被提交到阻塞队列中，线程池通过获取队列中的任务来执行。

Java中的java.util.concurrent包中提供了多种实现了阻塞队列接口的类，如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等，可以根据具体的场景和需求选择适合的阻塞队列实现类。

阻塞队列的实现原理主要依赖于底层的同步机制，使得在队列为空或者已满时能够阻塞线程。

通常，阻塞队列的实现会借助以下几种同步机制：

  1. 锁（Lock）：使用锁机制可以实现对队列的安全访问。通过获取锁来保护队列的状态，阻塞队列可以确保在对队列进行修改（如入队、出队）时是线程安全的。

  2. 条件变量（Condition）：条件变量提供了更灵活的线程等待和唤醒机制。阻塞队列可以利用条件变量，在某些条件满足时阻塞线程，并在其他线程改变了队列状态时唤醒它们。

  3. 信号量（Semaphore）：信号量是一种用于控制并发访问资源的计数器。阻塞队列可以使用信号量来限制队列的容量，当信号量计数器达到最大值时，将会阻塞对队列的访问。

具体的实现原理可能因不同的阻塞队列而异。例如，ArrayBlockingQueue内部使用了锁和条件变量来实现阻塞操作；LinkedBlockingQueue则使用了原子性操作和条件变量来实现阻塞操作。

当阻塞队列为空时，消费者线程试图获取元素时将被阻塞，直到有生产者往队列中插入元素并通知消费者线程；当队列已满时，生产者线程试图插入元素时同样会被阻塞，直到有消费者从队列中取出元素并通知生产者线程。

通过以上机制，阻塞队列能有效地控制并发线程之间的访问和通知，实现线程安全的数据交换和同步。

使用阻塞队列来实现生产者-消费者模型是一种简单而有效的方法，能够有效地解耦生产者和消费者，并且通过阻塞队列的特性来实现线程间的数据交换和同步。以下是使用阻塞队列实现生产者-消费者模型的一般步骤：

  1. 创建一个阻塞队列： 首先，需要选择合适的阻塞队列实现类（如ArrayBlockingQueue或LinkedBlockingQueue），并创建一个阻塞队列对象。

  2. 创建生产者和消费者线程： 分别创建生产者线程和消费者线程。生产者负责生成数据并将数据放入阻塞队列，而消费者则从队列中获取数据进行处理。

  3. 启动生产者和消费者线程： 启动生产者和消费者线程，它们将循环执行生产和消费的操作。

  4. 生产者向队列中添加数据： 在生产者线程中，生成数据并将数据放入阻塞队列。由于阻塞队列的特性，当队列已满时，生产者线程将会被阻塞，直到队列有空闲位置。

  5. 消费者从队列中获取数据： 在消费者线程中，从阻塞队列中获取数据进行处理。如果队列为空，消费者线程将被阻塞，直到队列中有数据可供获取。

通过以上步骤，生产者将数据放入阻塞队列，而消费者则从队列中获取数据，实现了生产者-消费者模型。由于阻塞队列的阻塞特性，生产者和消费者线程之间不需要显式的等待或通知机制，而是依靠队列本身的特性来实现线程间的同步和协作。

以下是一个使用 Java 中的 ArrayBlockingQueue 实现生产者-消费者模型的简单示例：

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

public class ProducerConsumerExample {
    private static final int CAPACITY = 10;
    private static BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(CAPACITY);

    public static void main(String[] args) {
        Thread producerThread = new Thread(new Producer());
        Thread consumerThread = new Thread(new Consumer());

        producerThread.start();
        consumerThread.start();
    }

    static class Producer implements Runnable {
        @Override
        public void run() {
            try {
                int value = 0;
                while (true) {
                    queue.put(value);
                    System.out.println("Produced " + value);
                    value++;
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class Consumer implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    int value = queue.take();
                    System.out.println("Consumed " + value);
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个示例中，生产者线程不断向阻塞队列中放入数据，而消费者线程不断从队列中获取数据进行处理，实现了生产者-消费者模型。

🍁🍁 14、什么是Callable和Future?

在Java中，Callable和Future是用于支持异步执行任务和获取任务执行结果的接口。

Callable是一个泛型接口，定义了一个call方法，该方法可以返回一个结果或抛出一个异常。与Runnable接口不同，Callable的call方法具有返回值。

下面是Callable接口的定义：

public interface Callable<V> {
    V call() throws Exception;
}

Future是一个表示异步计算结果的接口，提供了方法来检查任务是否完成、等待任务完成并获取结果、取消任务的执行等。

下面是Future接口的一些常用方法：

  • V get() throws InterruptedException, ExecutionException：等待任务完成并获取计算结果。
  • boolean isDone()：查询任务是否已完成。
  • boolean cancel(boolean mayInterruptIfRunning)：尝试取消任务的执行。

ExecutorService接口的方法submit可以用来提交实现了Callable接口的任务，并返回一个Future对象，用来获取任务执行的结果。

下面是使用Callable和Future的简单示例：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableFutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交一个Callable任务
        Future<Integer> future = executor.submit(new MyCallable());

        try {
            // 等待任务完成并获取结果
            int result = future.get();
            System.out.println("Task result: " + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        // 关闭线程池
        executor.shutdown();
    }

    static class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            // 模拟耗时操作
            Thread.sleep(2000);

            return 42;
        }
    }
}

在这个示例中，我们创建了一个ExecutorService线程池，提交了一个实现了Callable<Integer>接口的任务，并通过调用Future对象的get方法等待任务执行的结果。最后，我们关闭了线程池。

需要注意的是，Future的get方法会阻塞当前线程，直到任务完成并返回结果。如果任务无法完成（例如任务被取消或执行过程中抛出异常），get方法将会抛出相应的异常。在调用get方法之前，可以使用isDone方法来检查任务是否已完成。

🍁🍁 15、什么是FutureTask? 使用ExecutorService启动任务？

FutureTask是一个实现了RunnableFuture接口的类，它实现了Future和Runnable接口的功能。FutureTask既可以作为Runnable被线程执行，也可以作为Future获取任务执行的结果。

FutureTask可以用于异步执行任务，并在任务完成时获取结果。它提供了更多的灵活性和功能，可以用于以下几种情况：

  1. ** 执行Callable任务：** 可以将实现了Callable接口的任务提交给FutureTask，然后使用ExecutorService来执行这个任务，并获取任务的执行结果。
  2. ** 执行Runnable任务：** 可以将实现了Runnable接口的任务提交给FutureTask，然后使用ExecutorService来执行这个任务，但无法获取任务的执行结果（任务不返回结果）。
  3. ** 执行带有返回结果的任务：** 可以将已经完成计算的结果通过FutureTask返回，其他线程可以通过FutureTask的get方法来获取这个结果。

以下是一个使用FutureTask执行Callable任务的示例：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskExample {
    public static void main(String[] args) {
        Callable<Integer> callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);

        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(futureTask);

        try {
            int result = futureTask.get();
            System.out.println("Task result: " + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        executor.shutdown();
    }

    static class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(2000);
            return 42;
        }
    }
}

在这个示例中，我们创建了一个Callable<Integer>的实现类MyCallable，该任务会返回整数值42。然后，我们创建了一个FutureTask<Integer>对象，并将MyCallable实例传递给其构造函数。接下来，我们使用ExecutorService提交FutureTask来执行任务，并通过get方法等待任务完成并获取结果。

需要注意的是，get方法会阻塞当前线程，直到任务完成并返回结果。如果任务无法完成（例如任务被取消或执行过程中抛出异常），get方法将会抛出相应的异常。在调用get方法之前，可以使用isDone方法来检查任务是否已完成。

FutureTask还提供了其他一些方法，如cancel方法用于取消任务的执行，isCancelled方法用于判断任务是否已被取消等。

🍁🍁 16、什么是并发容器的实现？

并发容器是一种支持多线程并发操作的数据结构，它在多线程环境下能够提供线程安全的操作。在Java中，有许多并发容器的实现，包括ConcurrentHashMap、ConcurrentLinkedQueue、CopyOnWriteArrayList等。

这些并发容器的实现大多基于特定的并发算法和数据结构，以确保在多线程环境下保持数据的一致性和线程安全性。通常情况下，这些并发容器的实现会使用锁、原子操作、并发队列等技术来实现线程安全的数据操作。

以下是一些常见的并发容器及其主要特点：

  1. ConcurrentHashMap：是Map接口的线程安全实现，它使用分段锁（Segment）来实现并发访问。每个Segment相当于一个小的HashTable，不同的Segment上的操作可以并发进行，提高了并发性能。

  2. ConcurrentLinkedQueue：是Queue接口的线程安全实现，它使用CAS（Compare and Swap）操作和volatile变量来实现非阻塞式并发访问，保证了在多线程环境下的线程安全性和高效性能。

  3. CopyOnWriteArrayList：是List接口的线程安全实现，它通过在修改操作时复制一份新的数组来实现线程安全，读取操作不需要加锁，适用于读多写少的场景。

  4. ConcurrentSkipListMap和ConcurrentSkipListSet：它们是基于跳表（SkipList）数据结构实现的线程安全的Map和Set，在多线程环境下提供了较好的性能，并且支持有序性操作。

并发容器的实现涉及到复杂的并发算法和线程安全机制，它们旨在提供在多线程环境下高效并发操作的数据结构。在使用这些并发容器时，需要根据具体的业务场景和性能要求选择合适的实现，以及了解各种并发容器的特性和适用场景。

🍁🍁 17、什么是竞争条件？你怎样发现和解决竞争？

竞争条件（Race Condition）是指当多个线程并发访问共享资源，并试图同时修改该资源时，最终的结果依赖于不同线程执行的相对时间顺序，从而导致结果的不可预测性。

竞争条件的出现通常是由于并发访问共享资源时缺乏适当的同步操作，造成数据的不一致或不正确的结果。常见的竞争条件问题包括数据竞争、死锁、活锁等。

要发现竞争条件，可以采用以下几种方法：

  1. 代码审查： 通过仔细审查代码，尤其是涉及共享资源访问的部分，检查是否存在多线程并发访问、修改共享资源的情况。

  2. 并发测试： 编写并发测试用例，模拟多线程并发访问共享资源的情况，观察程序的行为和结果是否正确。如果发现结果与预期不符，可能存在竞争条件。

  3. 静态分析工具： 使用一些静态分析工具（例如FindBugs、SpotBugs、SonarQube等）来检测代码中的潜在竞争条件问题。

解决竞争条件问题可以采用以下几种方法：

  1. 同步机制： 使用锁（如synchronized、ReentrantLock）或其他线程同步机制来保证多线程对共享资源的访问具有互斥性，避免并发修改。

  2. 原子操作： 使用原子操作（如AtomicInteger、AtomicReference）来实现对共享资源的原子性访问，确保多线程操作的原子性。

  3. 并发容器： 使用线程安全的并发容器（如ConcurrentHashMap、ConcurrentLinkedQueue）来代替传统的非线程安全容器，以保证并发访问的线程安全性。

  4. 避免共享： 通过设计避免共享资源，在多线程操作中尽量减少对共享资源的竞争，例如通过线程本地变量（ThreadLocal）来保持每个线程的私有副本。

  5. 重构代码： 重新设计并重构代码，采用更合理的线程安全策略或数据结构，从根本上避免竞争条件。

需要注意的是，解决竞争条件问题需要综合考虑业务需求和性能要求，选择适当的同步机制和并发方案。此外，并发编程也需要仔细的设计和测试，确保线程安全性和正确性。

🍁🍁 18、你将如何使用threaddump？你将如何分析Threaddump？

Thread Dump（线程转储）是一种获取当前运行中线程的状态和堆栈信息的快照，可以帮助我们了解应用程序当前的线程状态、线程间的关系以及可能存在的问题。在Java中，可以使用jstack命令或相关工具生成线程转储。

下面是使用Thread Dump的基本步骤：

  1. 生成Thread Dump：可以使用jstack命令、JVM监控工具（如VisualVM、JConsole）或应用程序日志中的相关工具生成Thread Dump。例如，使用jstack命令可以执行类似 jstack <PID> 的命令来获取Java进程的线程转储。

  2. 分析Thread Dump：通过分析Thread Dump来了解线程的状态、堆栈信息、锁信息等，并发现可能存在的问题。以下是一些常见的分析方法：

    • 查看线程状态：可以通过Thread Dump中的线程状态（如RUNNABLE、WAITING、BLOCKED等）来了解线程的运行状态，判断是否存在死锁、死循环等问题。

    • 查看线程堆栈：Thread Dump中会显示每个线程的堆栈跟踪信息，可以定位到具体的代码行数，了解线程在执行哪些方法和调用栈。通常关注高CPU使用率、等待锁、阻塞等线程。

    • 查看锁信息：通过查看Thread Dump中的锁信息，可以了解线程间的锁关系、竞争情况，判断是否存在潜在的死锁或并发问题。

    • 分析线程间关系：通过观察Thread Dump中不同线程之间的关系，例如锁的拥有者、等待者等，可以分析线程间的交互和可能存在的问题。

  3. 解决问题：根据Thread Dump的分析结果，可以采取相应的措施来解决问题。例如，找到代码中的死锁或并发问题，进行相应的锁优化。或者根据线程堆栈信息，定位并修复代码中的逻辑错误或死循环。

分析Thread Dump需要一定的经验和技巧，因为Thread Dump可能会非常庞大且包含大量的线程信息。对于复杂的问题，可能需要使用一些辅助工具来帮助分析，例如线程分析工具（如ThreadDump Analyzer、FastThread、YourKit等）或性能分析工具（如VisualVM、JProfiler等）。

在分析Thread Dump时，需要结合实际问题和线程转储的上下文来进行分析和判断，定位问题的根本原因，并采取相应的措施来解决问题，提高应用程序的性能和稳定性。

🍁🍁 19、为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？

在Java中，线程的启动是通过调用Thread类的start()方法来实现的。start()方法会启动一个新的线程，并调用该线程的run()方法。

run()方法是线程的执行体，包含了线程需要执行的代码逻辑。在单线程环境下，可以直接调用run()方法来执行线程的代码，但是在多线程环境下，直接调用run()方法并不会创建新的线程，而是直接在当前线程中顺序执行run()方法的代码。这是因为在Thread类中，run()方法只是一个普通的方法，并没有创建新线程的功能。

为什么不能直接调用run()方法而要通过start()方法启动线程呢？这是因为线程的启动涉及到一些底层资源的分配和初始化，以及线程调度的安排。当调用start()方法时，底层会分配新的线程资源并将线程放入就绪队列中，等待CPU调度，最终会执行run()方法。而直接调用run()方法，则不会分配新的线程资源，代码会在当前线程中顺序执行，无法达到多线程的效果。

使用多线程的目的通常是为了实现并发执行，在并发执行的情况下能够充分利用多核处理器，提高程序的性能和效率。通过调用start()方法，可以启动多个并发的线程，每个线程执行自己的run()方法，从而实现并发执行的效果。

总结来说，调用start()方法可以创建新的线程并启动该线程，而直接调用run()方法只会在当前线程中按照顺序执行方法的代码。因此，在需要使用多线程并发执行的情况下，应该调用start()方法启动线程，而不是直接调用run()方法。

🍁🍁 20、多线程同步和互斥有几种实现方法，都是什么？

在多线程环境下，为了确保线程之间的安全性和正确性，需要使用同步和互斥机制。以下是几种常见的多线程同步和互斥的实现方法：

  1. 使用synchronized关键字： synchronized是Java中最基本的同步和互斥机制之一。通过在方法或代码块中使用synchronized关键字，可以使得只有一个线程可以进入被synchronized修饰的代码区域，其他线程需要等待。synchronized关键字可以应用于方法、代码块和静态方法。

  2. 使用ReentrantLock类： ReentrantLock是Java.util.concurrent包下提供的一种显示锁实现方式。通过使用ReentrantLock及其相关方法（如lock()和unlock()），线程可以精确地控制锁的获取和释放，以实现同步和互斥操作。

  3. 使用Condition条件： Condition是ReentrantLock提供的一种等待/通知机制，可以在等待某个条件满足时释放锁并进入等待状态，当条件被满足时被唤醒并重新获取锁。通过使用Condition，可以更灵活地控制线程的等待和执行顺序。

  4. 使用Semaphore信号量： Semaphore是一种计数信号量，在同一时间内允许多个线程同时访问某个资源或代码段。通过使用Semaphore可以实现一些限流和控制访问的场景。

  5. 使用volatile关键字： volatile关键字用于保证变量的可见性和禁止指令重排序，它可以在多线程环境下保证变量的读取和写入的顺序性。volatile关键字适用于一些简单的标志位的读写操作。

这些是常见的多线程同步和互斥的实现方法，它们各自适用于不同的场景和需求。在实际使用时，应根据具体的情况选择适合的同步和互斥机制，并灵活运用。此外，还可以使用并发集合（如ConcurrentHashMap、ConcurrentLinkedQueue等）和并发工具类（如CountDownLatch、CyclicBarrier等）等来辅助实现多线程的同步和互斥操作。

在Java中，多线程同步可以使用synchronized关键字或者Lock对象来实现。其中，synchronized是隐式锁，它与每个对象相关联，并自动获得和释放锁。而Lock对象是显示锁，需要手动获得和释放锁。

下面是使用synchronized关键字实现多线程同步的示例：

public class MyThread implements Runnable {
    private int count;

    public void run() {
        synchronized(this) {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " count: " + count);
                count++;
            }
        }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread, "Thread-1");
        Thread thread2 = new Thread(myThread, "Thread-2");

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

        thread1.join();
        thread2.join();

        System.out.println("Final count is " + myThread.getCount());
    }
}

上面的示例中，MyThread类实现了Runnable接口，并使用synchronized关键字来同步count变量的访问。在Test类中，创建了两个线程来执行MyThread对象中的run()方法。

除了synchronized关键字，Java还提供了一些其他的互斥实现方法，包括：

  1. ReentrantLock：是一个可重入的锁，与synchronized类似，但是具有更高的灵活性和可扩展性，例如可中断、可轮询和超时锁等功能。
  2. ReadWriteLock：允许多个并发线程同时读取某个共享资源，但是对于写操作仍然需要互斥锁来保证同步性。
  3. Semaphore：用于控制同时访问某个资源的线程数量。
  4. CountdownLatch：允许一个或多个线程等待一组事件的完成。
  5. CyclicBarrier：允许多个线程等待彼此达到某个共同的执行状态，然后再继续执行。

在这里插入图片描述

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