避免死锁需打破四个必要条件，常用策略包括统一锁顺序、使用tryLock()或设置超时；内存泄漏主因有静态集合持有对象、资源未关闭等，可通过工具分析和代码审查排查；并发集合选择应根据读写比例、排序及阻塞需求，如ConcurrentHashMap适用于高并发读写，CopyOnWriteArrayList适合读多写少。
Java面试中，多线程和内存管理常常是区分候选人水平的关键。陷阱题的目的在于考察你对底层原理的理解和实际问题解决能力，而不是简单的概念背诵。
多线程与内存管理是Java面试中的高频考点，也是区分候选人技术深度的重要手段。理解这些陷阱背后的原理，能让你在面试中脱颖而出。
如何避免java多线程中的死锁？
死锁是多线程编程中常见的问题，它发生在两个或多个线程相互等待对方释放资源，导致所有线程都无法继续执行的情况。避免死锁的关键在于打破形成死锁的四个必要条件：互斥、占有且等待、不可剥夺、循环等待。
一种常见的策略是使用锁的顺序性。这意味着所有线程都按照相同的顺序获取锁。例如，如果线程需要同时获取锁A和锁B，那么所有线程都应该先获取锁A，然后再获取锁B。这可以避免循环等待的发生。
立即学习“Java免费学习笔记（深入）”；
另一个方法是使用
tryLock()
方法。
tryLock()
允许线程尝试获取锁，如果锁已经被其他线程占用，则立即返回，而不是无限期地等待。线程可以检查
tryLock()
的返回值，如果获取锁失败，则可以释放已经持有的锁，稍后再尝试。
此外，设置锁的超时时间也是一种有效的策略。如果线程在指定的时间内无法获取锁，则放弃等待。这可以防止线程永久阻塞，从而避免死锁的发生。
举个例子，假设有两个线程Thread1和thread2，需要访问资源A和资源B。
Object resourceA = new Object(); Object resourceB = new Object(); // Thread 1 new Thread(() -> { synchronized (resourceA) { System.out.println("Thread 1: Holding resource A..."); try { Thread.sleep(10); } catch (InterruptedException e) {} System.out.println("Thread 1: Waiting for resource B..."); synchronized (resourceB) { System.out.println("Thread 1: Acquired resource B."); } } }).start(); // Thread 2 new Thread(() -> { synchronized (resourceB) { System.out.println("Thread 2: Holding resource B..."); try { Thread.sleep(10); } catch (InterruptedException e) {} System.out.println("Thread 2: Waiting for resource A..."); synchronized (resourceA) { System.out.println("Thread 2: Acquired resource A."); } } }).start();
这段代码很容易导致死锁。Thread 1 持有 resourceA 等待 resourceB，而 Thread 2 持有 resourceB 等待 resourceA。解决这个问题，可以统一加锁顺序：
Object resourceA = new Object(); Object resourceB = new Object(); // Thread 1 new Thread(() -> { synchronized (resourceA) { System.out.println("Thread 1: Holding resource A..."); try { Thread.sleep(10); } catch (InterruptedException e) {} System.out.println("Thread 1: Waiting for resource B..."); synchronized (resourceB) { System.out.println("Thread 1: Acquired resource B."); } } }).start(); // Thread 2 new Thread(() -> { synchronized (resourceA) { // 统一先获取 resourceA System.out.println("Thread 2: Holding resource A..."); try { Thread.sleep(10); } catch (InterruptedException e) {} System.out.println("Thread 2: Waiting for resource B..."); synchronized (resourceB) { System.out.println("Thread 2: Acquired resource B."); } } }).start();
Java内存泄漏的常见原因及排查方法
Java内存泄漏指的是程序中已分配的内存空间，由于某种原因无法被垃圾回收器回收，导致内存占用不断增加，最终可能导致程序崩溃。常见的内存泄漏原因包括：
- 静态集合类持有对象： 如果一个对象被添加到静态集合类（如静态的
ArrayList
或
HashMap
）中，并且没有被显式地移除，那么这个对象将一直存在于内存中，即使程序不再需要它。
- 未关闭的资源： 例如，打开的文件流、数据库连接、网络连接等，如果没有在使用完毕后及时关闭，会导致资源无法释放，从而造成内存泄漏。
- 监听器和回调： 如果一个对象注册了监听器或回调函数，但是没有在不再需要时取消注册，那么这个对象将一直被监听器或回调函数引用，导致无法被回收。
- 内部类持有外部类引用： 非静态内部类会隐式地持有外部类的引用。如果内部类的实例生命周期比外部类长，那么外部类实例将无法被回收。
- ThreadLocal变量使用不当：
ThreadLocal
用于存储线程局部变量。如果
ThreadLocal
变量在使用完毕后没有被
remove()
，那么它将一直存在于线程的生命周期中，可能导致内存泄漏。
排查Java内存泄漏的方法包括：
- 使用内存分析工具： 常用的内存分析工具包括VisualVM、MAT (Memory Analyzer Tool)等。这些工具可以帮助你分析Java堆的dump文件，找出内存泄漏的根源。
- 观察jvm监控数据： 通过JVM监控工具（如JConsole、VisualVM）观察堆内存的使用情况。如果发现堆内存持续增长，且垃圾回收频率很高，则可能存在内存泄漏。
- 代码审查： 仔细检查代码，特别是涉及到资源管理、监听器、回调函数、集合类和
ThreadLocal
变量的部分，查找可能导致内存泄漏的地方。
- 使用Profiler： Profiler可以帮助你分析程序的性能瓶颈，并找出内存分配的热点。通过分析内存分配的热点，可以更容易地发现内存泄漏的原因。
一个简单的例子：
import java.util.ArrayList; import java.util.List; public class MemoryLeakExample { private static List<Object> list = new ArrayList<>(); public void addToList(Object obj) { list.add(obj); } public static void main(String[] args) { MemoryLeakExample example = new MemoryLeakExample(); for (int i = 0; i < 1000000; i++) { example.addToList(new Object()); } System.out.println("Finished adding objects to the list."); // list 仍然持有大量对象，导致内存泄漏 } }
在这个例子中，静态的
list
会一直持有大量的
Object
对象，导致内存泄漏。解决办法是在不需要这些对象时，从
list
中移除它们，或者将
list
设置为局部变量。
如何选择合适的Java并发集合类？
Java提供了多种并发集合类，用于在多线程环境下安全地访问和修改数据。选择合适的并发集合类取决于具体的应用场景和性能需求。
-
ConcurrentHashMap
：
适用于高并发的读写操作，它使用了分段锁技术，允许多个线程同时访问不同的段，从而提高并发性能。 -
CopyOnWriteArrayList
：
适用于读多写少的场景。每次修改操作都会创建一个新的数组副本，并将修改应用到副本上，然后将引用指向新的数组。读操作不需要加锁，因此并发性能很高。 -
ConcurrentLinkedQueue
：
适用于高并发的队列操作。它是一个无界非阻塞队列，使用了CAS (Compare and Swap) 操作来实现线程安全。 -
BlockingQueue
：
适用于生产者-消费者模式。它是一个阻塞队列，当队列为空时，消费者线程会阻塞等待；当队列已满时，生产者线程会阻塞等待。常见的BlockingQueue
实现包括
ArrayBlockingQueue
、
LinkedBlockingQueue
、
PriorityBlockingQueue
等。
-
ConcurrentSkipListMap
和
ConcurrentSkipListSet
：
适用于需要排序的并发场景，基于跳表实现，提供高效的并发访问和排序功能。
选择并发集合类时，需要考虑以下因素：
- 并发级别： 并发级别越高，需要选择并发性能更好的集合类。
- 读写比例： 读多写少的场景可以选择
CopyOnWriteArrayList
，读写均衡的场景可以选择
ConcurrentHashMap
。
- 是否需要排序： 如果需要排序，可以选择
ConcurrentSkipListMap
或
ConcurrentSkipListSet
。
- 是否有阻塞需求： 如果需要阻塞等待，可以选择
BlockingQueue
。
例如，如果需要在高并发环境下缓存数据，并且读操作远多于写操作，那么
ConcurrentHashMap
结合本地缓存（如guava Cache）可能是一个不错的选择。而如果需要实现一个生产者-消费者模式，那么
BlockingQueue
则是最佳选择。
import java.util.concurrent.ConcurrentHashMap; public class ConcurrentHashMapExample { private static ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>(); public static void main(String[] args) throws InterruptedException { // 多个线程并发写入 Thread writer1 = new Thread(() -> { for (int i = 0; i < 1000; i++) { map.put("key" + i, "value" + i); } }); Thread writer2 = new Thread(() -> { for (int i = 1000; i < 2000; i++) { map.put("key" + i, "value" + i); } }); writer1.start(); writer2.start(); writer1.join(); writer2.join(); System.out.println("Map size: " + map.size()); // 最终大小应该是2000 } }
这个例子展示了
ConcurrentHashMap
在高并发写入场景下的应用。即使多个线程同时写入数据，
ConcurrentHashMap
也能保证线程安全。
评论（已关闭）
评论已关闭