就只说 3 个 Java 面试题 —— 02

4、Java 中如何处理对 Collection 的并发修改？

对 Java 中的集合进行并发修改可能会导致一系列问题，例如意外行为、不确定的结果，甚至抛出 ConcurrentModificationException。要处理 Java 中集合的并发修改，您可以使用以下方法之一：

• 使用同步集合：处理集合并发修改的一种方法是使用同步集合。同步集合是一种线程安全的集合，可确保一次只有一个线程可以修改该集合。我们可以通过调用 Collections.synchronizedCollection() 方法来创建同步集合，并传入要同步的集合。例如：

List<String> list = new ArrayList<>();  
List<String> synchronizedList = Collections.synchronizedList(list);
1
2

• 使用并发集合：处理集合并发修改的另一种方法是使用并发集合。并发集合是线程安全的集合，允许多个线程同时修改集合，而无需外部同步。 (java.util.concurrent) 包提供了一系列并发集合类，例如 ConcurrentHashMap、ConcurrentLinkedDeque 和 ConcurrentSkipListSet。

• 使用显式锁定：我们还可以使用显式锁定来处理对集合的并发修改。我们可以在修改集合时使用synchronized关键字或者(java.util.concurrent.locks)包来锁定集合。例如：

List<String> list = new ArrayList<>();
synchronized(list) {
    list.add(“foo”);
}
1
2
3
4

• 正确使用迭代器：迭代集合时，应使用 Iterator 接口以避免并发修改。如果您在使用迭代器迭代集合时修改集合，您将收到 ConcurrentModificationException。相反，您可以使用迭代器的remove() 方法在迭代集合时从集合中删除元素。例如：

List<String> list = new ArrayList<>();  
Iterator<String> iterator = list.iterator();  
while (iterator.hasNext()) {  
    String element = iterator.next();  
    if (someCondition) {  
        iterator.remove();
    }  
}
1
2
3
4
5
6
7
8

5、Java中如何实现死锁情况？

Java 中的死锁是指两个或多个线程永远被阻塞，等待对方释放它们所持有的锁或资源。在 Java 中实现死锁情况涉及创建一个场景，其中两个或多个线程被阻塞、相互等待并且无法进一步继续。下面是如何在 Java 中创建死锁的示例：

public class Main {  

    private static final Object lock1 = new Object();  
    private static final Object lock2 = new Object();  

    public static void main(String[] args) {  
  
        Thread thread1 = new Thread(() -> {  

            synchronized (lock1) {  
                System.out.println(“Thread 1 acquired lock 1”);  
                try {  
                    Thread.sleep(100);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }
             
                synchronized (lock2) {  
                    System.out.println(“Thread 1 acquired lock 2”);  
                }  
            }  
        });  
  

        Thread thread2 = new Thread(() -> {  

            synchronized (lock2) {  
                System.out.println(“Thread 2 acquired lock 2”);  
                try {  
                    Thread.sleep(100);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  

                synchronized (lock1) {  
                    System.out.println(“Thread 2 acquired lock 1”);  
                }  
            }  
        });  

        thread1.start();  
        thread2.start();  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

在此示例中，我们有两个线程，thread1 和 thread2，每个线程都尝试获取两个锁：lock1 和 lock2。

• 线程1首先获取锁1，然后等待100毫秒，然后再尝试获取锁2。
• 同时，thread2 获取了lock2，并等待100 毫秒后才尝试获取lock1。

由于两个线程都在等待对方释放它们所持有的锁，因此会产生死锁情况，程序将永远卡住，无法继续进行。

6、你能解释一下Java中“Reader-Writer”锁和“ReentrantReadWriteLock”之间的区别吗？哪个使用起来更灵活？

读写锁：

读写锁允许多个线程同时读取共享资源，但一次只有一个线程可以写入。当一个线程想要写入资源时，它必须等待所有读取者完成读取才能获取锁。

读写锁是不可重入的，这意味着持有读锁的线程在不释放读锁的情况下无法获取写锁。类似地，持有写锁的线程在不释放写锁的情况下无法获取读锁。

可重入读写锁：

ReentrantReadWriteLock 是读写锁的更灵活的实现。它允许多个线程同时获取读锁，也允许持有读锁的线程无需先释放读锁即可获取写锁。这使得线程可以将读锁升级为写锁。

另外，ReentrantReadWriteLock是可重入的，这意味着持有锁进行读或写的线程可以再次获取锁，而无需先释放锁。

总的来说，可重入读写锁比读写锁提供了更多的灵活性，但它也更复杂，如果使用不当，可能会导致死锁。当需要对锁进行更细粒度的控制时，通常建议使用 ReentrantReadWriteLock，而当需要简单性时，建议使用 Reader-Writer 锁。