2024年150道高频Java面试题（二十七）

53. 什么是 Java 中的死锁？如何避免？

Java中的死锁是指两个或两个以上的线程因为竞争资源而造成的一种僵持状态，每个线程都在等待其他线程释放锁，但是这些锁又被其他线程持有，导致没有任何线程能继续执行下去，形成一种循环等待的局面。

死锁通常发生在以下四个条件同时满足时：

互斥条件：资源不能被多个线程共同使用，只能由一个线程独占。
占有且等待条件：线程至少持有一个资源，并且正在等待获取额外的资源，而该资源又被其他线程持有。
非抢占条件：线程持有的资源在未使用完毕前不能被其他线程强行抢占。
循环等待条件：存在一个线程与资源之间的循环等待链，每个线程都在等待下一个线程所持有的资源。

避免死锁的策略包括：

破坏死锁的四个必要条件之一：
- 互斥条件无法破坏，因为它是资源使用的必要条件。
- 通过一次性请求所有需要的资源来破坏占有且等待条件。
- 允许线程剥夺已占有的资源，破坏非抢占条件。
- 通过资源的有序分配来破坏循环等待条件，比如对所有资源进行编号，线程按编号顺序请求资源。
避免策略：
- 设计合理的资源申请顺序，保证所有线程按照相同的顺序请求资源。
- 减少资源的占有时间，尽快释放不再需要的资源。
- 使用锁排序，确保所有线程都按照固定的全局顺序获取锁。
检测与恢复：
- 通过资源分配图或者银行家算法来检测死锁，一旦检测到死锁，采取措施解除。
- 通过线程回滚或者资源抢占来回滚到没有死锁的状态。
避免长时间锁：
- 使用尝试获取锁的机制，如 tryLock() 方法，如果不能立即获取锁，则放弃。
- 对锁进行超时处理，超时后自动放弃锁，减少资源占用时间。

以下是一个简单的死锁示例：

public class DeadlockDemo {
    public static void main(String[] args) {
        final Object resource1 = "Resource1";
        final Object resource2 = "Resource2";

        Thread t1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Locked resource 2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (resource1) {
                    System.out.println("Thread 2: Locked resource 1");
                }
            }
        });

        t1.start();
        t2.start();
    }
}

在上面的代码中，如果两个线程同时执行，并且分别获得了不同的锁，然后试图获取对方持有的锁，就可能导致死锁的发生。通过上述避免策略，我们可以重新设计代码，以避免这种潜在的问题。

54. synchronized 和 volatile 关键字有何区别？

synchronized和volatile是Java中的两个关键字，它们被用于控制多线程访问共享资源时的同步问题。

作用域不同：
- synchronized可以修饰方法或代码块，它可以保证在同一时刻只有一个线程可以执行某个方法或代码块。
- volatile只能用来修饰变量，确保对变量的读写操作对所有线程立即可见。
内存语义：
- 使用synchronized时，当线程进入同步代码块或方法，它会清空工作内存中的共享变量值，从主内存中重新读取。当线程退出同步代码块或方法时，它会将工作内存中的共享变量的最新值刷新回主内存。
- volatile变量则是直接从主内存读取，对它的写操作也会直接写入主内存，保证了新值对其他线程的可见性。
操作粒度：
- synchronized的操作粒度比较粗，它锁定的是整个方法或代码块，在锁定期间其他线程无法访问同步资源。
- volatile的操作粒度比较细，仅保证对单个变量的读写操作的可见性和有序性。
锁的影响：
- synchronized可以给方法或代码块加锁，导致线程在执行时会阻塞，等待锁的释放。
- volatile不会造成线程的阻塞。
有序性：
- synchronized保证了操作的有序性，即进入同步代码块或方法的操作将在退出同步代码块或方法之前全部执行完毕。
- volatile通过禁止指令重排优化，也保证了操作的有序性。

以下是一个使用synchronized和volatile的示例：

public class Counter {
    // 使用volatile修饰共享变量
    private volatile int count = 0;

    // 使用synchronized修饰方法
    public synchronized void increment() {
        count++; // 这里隐式地使用了count变量
    }

    public int getCount() {
        return count; // 这里读取volatile变量
    }
}

在这个示例中，increment方法使用了synchronized，确保了在执行count++操作时，其他线程不能同时访问该方法。而变量count被声明为volatile，保证了count值的变化对其他线程是可见的。

总结来说，synchronized用于控制多线程访问资源的同步，关注的是操作的原子性和线程的互斥；而volatile关注的是变量访问的可见性和有序性，但不保证复合操作的原子性。
领【150 道精选 Java 高频面试题】请go公众号：码路向前。

黑马非马.