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

迈不过友情╰ 2024-03-02 09:23 13阅读 0赞

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

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

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

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

*  使用并发集合：处理集合并发修改的另一种方法是使用并发集合。并发集合是线程安全的集合，允许多个线程同时修改集合，而无需外部同步。 (java.util.concurrent) 包提供了一系列并发集合类，例如 ConcurrentHashMap、ConcurrentLinkedDeque 和 ConcurrentSkipListSet。
 *  使用显式锁定：我们还可以使用显式锁定来处理对集合的并发修改。我们可以在修改集合时使用synchronized关键字或者(java.util.concurrent.locks)包来锁定集合。例如：

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

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

List<String> list = new ArrayList<>();  
    Iterator<String> iterator = list.iterator();  
    while (iterator.hasNext()) {
          
        String element = iterator.next();  
        if (someCondition) {
          
            iterator.remove();
        }  
    }

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

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

![image.png][]

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();  
        }  
    }

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

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

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

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

***读写锁：***

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

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

***可重入读写锁：***

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

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

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

[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/6d4bc3c2daf54958a87d911203611c09.png