Java 并发编程常见问题

1、线程状态它们之间是如何扭转的？

1、谈谈对于多线程的理解？

1、对于多核CPU，多线程可以提升CPU的利用率；

2、对于多IO操作的程序，多线程可以提升系统的整体性能及吞吐量；

3、使用多线程在一些场景下可以提升程序的处理效率；

2、哪些场景下使用多线程比较合适？为什么？

1、使用线程池，线程隔离，对服务做保护作用；

2、IO密集型程序（有较多线程是出于等待状态），多线程可以并发处理多个任务，提升效率；

3、批量任务处理，可以使用多线程提升速度；

4、使用多线程处理多个任务，可以让多个任务执行看起来是一起执行的（比如游系效果）-平均分配cpu资源，而不是存在明显的断层跟不连贯；

3、多线程并发安全怎么控制？

【加锁-确保并发情况下线程安全】

在多线程编程中，确保并发安全是非常重要的，避免数据竞争和其他线程间的冲突。以下是一些常见的方法和技术来控制多线程并发安全：

1. 互斥锁（Mutex）和同步块：

   • 使用互斥锁（Mutex）或者同步块（Synchronized Block）来保护共享资源。通过在访问共享资源的关键代码段周围放置锁来确保一次只有一个线程可以访问该资源。这样可以避免多个线程同时修改数据造成的问题。

2. 原子操作：

   • 对于一些基本的数据类型（如整数、布尔值），可以使用原子操作来确保操作的原子性。在Java中，可以使用 AtomicInteger、AtomicBoolean等类来实现原子操作，从而避免了使用锁时可能引入的性能开销。

3. 线程安全的数据结构：

   • 使用线程安全的数据结构，如 ConcurrentHashMap、CopyOnWriteArrayList等，这些数据结构内部实现了加锁机制或者采用了其他的线程安全策略，能够在高并发场景下安全地操作数据。

4. 使用并发工具类：

   • Java提供了多种并发工具类，如 Semaphore、CountDownLatch、CyclicBarrier等，它们能够帮助控制多线程间的协调和同步，确保线程安全性。

5. 避免可变状态：

   • 尽量减少共享状态的使用，特别是可变状态。如果某个数据可以设计为不可变对象，则避免多线程并发修改。不可变对象在多线程环境中通常是线程安全的。

6. 使用线程安全的第三方库：

   • 对于特定的需求，可以使用已经经过充分测试和验证的线程安全的第三方库，如并发集合、并发队列等。

7. 合理的线程设计：

   • 在设计多线程程序时，合理规划线程的职责和数据共享范围，避免过多的锁竞争和复杂的同步逻辑。

8. 测试和调试：

   • 对多线程程序进行充分的测试，包括并发测试和性能测试，以确保程序在高并发和负载下的稳定性和正确性。

综上所述，确保多线程并发安全的关键在于合理的使用锁、使用线程安全的数据结构、避免共享可变状态、以及对程序进行充分的测试和调试。这些方法可以帮助有效地管理多线程程序中的并发问题，提升系统的稳定性和性能。

4、AQS是用来做什么的？谈谈对它的理解

AQS（AbstractQueuedSynchronizer）是Java中一个重要的同步框架，用于实现锁和其他同步器的基础设施。它在并发编程中起着关键作用，主要用来管理同步状态和控制多线程对共享资源的访问。

主要作用和功能：

1. 提供了一个框架：

   • AQS提供了一种基于FIFO等待队列的同步器框架，可以通过继承和重写其方法来实现各种同步器，如独占锁（ReentrantLock）、共享锁（Semaphore、CountDownLatch）、同步队列等。

2. 状态管理：

   • AQS内部维护了一个整型状态（state），可以表示资源的占用情况或者其他自定义的状态信息。开发者可以通过操作状态来控制并发访问，例如获取锁、释放锁等。

3. 线程的排队与唤醒：

   • AQS利用了等待队列（CLH队列）来管理获取同步状态失败的线程，这些线程会被阻塞并按照FIFO顺序排队等待唤醒。当同步状态可用时，AQS会负责按照规定的策略唤醒合适的线程。

4. 内置了同步操作的基础：

   • AQS提供了acquire和release等核心方法，这些方法定义了同步器的获取和释放行为。具体的同步器可以通过重写这些方法来实现自定义的同步逻辑，例如独占锁的获取和释放。

5. 可扩展性：

   • AQS是一个抽象类，提供了良好的扩展性和定制性。开发者可以基于AQS实现自己的同步器，满足特定的并发控制需求。

对AQS的理解：

AQS的设计理念是基于"状态"和"等待队列"的管理，通过状态来反映同步资源的占用情况，通过等待队列来管理竞争同步资源失败的线程。它的核心思想是将共享资源的访问控制和线程调度分离开来，使得同步逻辑更加灵活和高效。

在实际应用中，开发者可以利用AQS提供的基础设施，如状态管理和线程排队机制，来实现复杂的并发控制。常见的应用场景包括实现独占锁、共享锁、倒计时器等，并通过AQS提供的方法来确保线程安全和资源正确的并发访问。

总结来说，AQS作为Java并发包中的核心组件，为开发者提供了一个强大的同步框架，通过其提供的状态管理和线程调度机制，实现了高效、可扩展的并发控制方案。

5、线程安全-加锁需要注意一些什么？死锁是怎么造成的？

1、加锁的顺序要一致，避免加锁的嵌套；

2、加锁的范围尽可能的小，减少互斥，提升性能；

3、如果可以使用乐观锁或者“无锁机制”那么就不要使用锁；

4、损耗性能的操作非必要可以从同步逻辑中移除，减少加锁时长；

死锁：

Java死锁是由于多个线程在争夺共享资源时出现的一种特定情况，其中每个线程都在等待其他线程释放它所需的资源，导致所有线程都被阻塞，无法继续执行下去。

死锁通常发生在多个线程同时持有多个锁，并且每个线程试图获取其他线程已持有的锁时。为了形象化地解释，可以举一个简单的例子：

假设有两个线程 A 和 B，以及两个共享资源 X 和 Y，它们的执行过程如下：

1. 线程 A 已经获取了资源 X 的锁，但是需要资源 Y 才能继续执行。
2. 同时，线程 B 已经获取了资源 Y 的锁，但是需要资源 X 才能继续执行。

这时候，线程 A 和 B 都在等待对方释放所需的资源，而导致彼此永远无法继续下去，这种情况就是死锁。

造成死锁的四个必要条件称为死锁的四个必要条件，它们是：

1. 互斥条件：至少有一个资源必须是被排他性控制的，即一次只能被一个线程使用。
2. 请求与保持条件：一个线程因请求资源而阻塞时，对已获得的资源保持不放。
3. 不剥夺条件：已获得的资源在未使用完之前，不能被其他线程强行剥夺，只能由自己释放。
4. 循环等待条件：若干线程之间形成一种头尾相接的循环等待资源的关系。

在Java中，死锁通常发生在使用多个锁对象并且锁的获取顺序不当时。为了避免死锁，开发者通常需要注意以下几点：

• 锁的顺序：尽量确保所有线程按照相同的顺序获取锁。
• 避免持有锁的时间过长：减少锁定资源的时间可以降低死锁发生的可能性。
• 使用线程池和并发工具类：Java提供了一些并发工具类（如 ExecutorService、ConcurrentHashMap 等），它们在设计时已经考虑了线程安全问题，可以减少手动管理锁的需求。

通过理解死锁的原因和条件，并采取适当的措施来规避，可以有效地避免Java程序中的死锁问题。

6、出现死锁以后会有什么现象？如何排查？

当程序出现死锁时，通常会表现为以下几种现象：

1. 程序停止响应：所有涉及到死锁的线程都会停止执行，程序无法继续向前执行，表现为卡住或者无响应状态。

2. 资源利用率不高：由于死锁导致部分线程或资源无法正常工作，整体资源利用率会下降，CPU等待时间增加。

3. 日志或调试信息：一些开发环境或运行时会记录死锁信息或者相关线程的状态信息，这些信息有助于排查死锁。

4. 如果是多线程或者是线程池的应用场景，出现死锁后会出现大量的线程被消耗并且阻塞等待获取锁。比如-dubbo-线程池。

使用 jstack 工具来定位死锁问题通常需要以下步骤：

1. 确定Java进程ID：首先，需要确定出现死锁问题的Java进程的ID。可以通过命令行或者任务管理器等工具获取。

2. 获取线程堆栈信息：在命令行中执行 jstack 命令来获取Java进程的线程堆栈信息。命令格式为：

   jstack <pid>

   其中 <pid> 是Java进程的ID。

3. 分析堆栈信息：jstack 命令会打印出当前Java进程中每个线程的堆栈跟踪信息。关注以下几点来分析可能的死锁情况：

   • 线程状态：查看每个线程的状态，例如是否处于 BLOCKED（被阻塞等待锁）、WAITING（无限期等待另一个线程来执行特定操作）、TIMED_WAITING（有时限等待）等状态。
   • 线程持有的锁：检查每个线程当前持有的锁对象。
   • 线程等待的锁：查看每个线程正在等待的锁对象。

4. 寻找死锁线程：在堆栈信息中寻找可能的死锁线程，即那些处于 BLOCKED 状态并且等待某个资源释放的线程。

5. 定位死锁原因：根据 jstack 输出的信息，分析死锁的具体原因。通常死锁发生的原因包括锁的竞争、顺序不当等。

6. 解决死锁问题：根据分析的结果，修改程序代码来避免死锁的发生。可能的解决方法包括调整锁的获取顺序、减少锁的持有时间、使用并发工具类等。

7. 验证和测试：修改代码后，进行相应的测试和验证，确保死锁问题已经解决或者得到显著改善。

通过以上步骤，可以利用 jstack 命令有效地定位和解决Java程序中的死锁问题。

Dubbo_JStack.log 文件

Dubbo_JStack.log 文件通常是用来记录 Dubbo 进程的线程堆栈信息的文件。在 Dubbo 的运行过程中，特别是当遇到一些问题如死锁、线程池耗尽等情况时，Dubbo 可能会记录线程的堆栈信息到 Dubbo_JStack.log 文件中，以便后续的故障诊断和分析。

这个文件通常不是自动创建的，而是需要一些特定的配置或者触发条件才会生成。具体来说，可以通过如下方式生成 Dubbo_JStack.log 文件：

1. 手动生成：可以手动使用 jstack 命令来获取 Dubbo 进程的线程堆栈信息，并将输出重定向到 Dubbo_JStack.log 文件中，例如：

   jstack <pid> > Dubbo_JStack.log

   其中 <pid> 是 Dubbo 进程的ID。

2. Dubbo 日志配置：有些情况下，Dubbo 的日志配置文件中可能包含配置项来指定是否记录线程堆栈信息，以及记录的文件位置。通常需要查看具体的 Dubbo 日志配置文件（如 log4j.properties 或者 logback.xml）来了解是否有相关的配置项。

3. 调试或监控工具：一些调试或监控工具可能会自动记录 Dubbo 进程的线程堆栈信息到类似 Dubbo_JStack.log 的文件中，这些工具通常提供了故障诊断和监控功能，帮助用户定位和解决问题。

总之，Dubbo_JStack.log 文件通常是用来存储 Dubbo 进程的线程堆栈信息的，它的生成方式可能是手动执行 jstack 命令或者通过某些监控或调试工具自动生成的。

7、并行跟并发的区别是什么？

1. 并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。
2. 并行：单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的“同时进行”。
3. 串行：有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。

8、为什么 wait ，notify 和 notifyAll 必须在同步方法或者同步块中被调用？

如果不在获取了obj锁的前提下调用方法，抛出了 java.lang.IllegalMonitorStateException 异常信息。

抛出 IllegalMonitorStateException 异常是由于调用wait方法的时当前线程没有获取到调用对象的锁。

wait和notify方法介绍
wait和notify是Object类中定义的方法。调用这两个方法的前提条件：当前线程拥有调用者的锁。
wait方法有好几个重载方法，但最终都调用了如下的wait本地方法。调用wait方法后，当前线程会进入waiting状态直到其他线程调用此对象的notify、notifyAll方法或者指定的等待时间过去。

public final native void wait(long timeout) throws InterruptedException;

notify和notifyAll方法,两者的区别是notify方法唤醒一个等待在调用对象上的线程，notifyAll方法唤醒所有的等待在调用对象上的线程。
那么唤醒后的线程是否就可以直接执行了？ 答案是否定的。唤醒后的线程需要获取到调用对象的锁后才能继续执行。

public final native void notify();
public final native void notifyAll();

9、介绍一下线程池

ThreadPoolExecutor 略...

其它待补充....

20、ConcurrentHashMap为什么不允许插入Null?

参考文章：

https://blog.51cto.com/u_11702014/6235764