性能瓶颈：Java多线程编程中的同步问题实例？

原创素颜马尾好姑娘i 2024-09-29 09:09 45阅读 0赞

在Java多线程编程中，同步问题主要体现在以下几种情况：

1. **死锁**：多个线程相互等待对方释放资源，导致所有线程都无法继续执行。例如：

```java
class DeadLock {
    final Object lock1 = new Object();
    final Object lock2 = new Object();

void thread1() {
        synchronized (lock1) {
            synchronized (lock2) {
                System.out.println("Thread 1: Acquiring lock1");
                lock1.wait(); // 线程释放锁1，进入等待状态
                System.out.println("Thread 1: Acquiring lock2");
                lock2.wait(); // 线程释放锁2，进入等待状态
                System.out.println("Thread 1: Both locks acquired. Exiting.");
            }
        }
    }

void thread2() {
        synchronized (lock2) {
            synchronized (lock1) {
                System.out.println("Thread 2: Acquiring lock2");
                lock2.notify(); // 线程释放锁2，唤醒等待的线程
                System.out.println("Thread 2: Acquiring lock1");
                lock1.notify(); // 同样操作，唤醒等待的线程
                System.out.println("Thread 2: Both locks acquired. Exiting.");
            }
        }
    }

public static void main(String[] args) {
        DeadLock deadlock = new DeadLock();
        Thread thread1 = new Thread(deadlock::thread1));
        Thread thread2 = new Thread(deadlock::thread2));

thread1.start();
        thread2.start();

try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，线程`Thread 1`等待锁`lock1`释放后再尝试获取锁`lock2`。同样，线程`Thread 2`也遵循相同的逻辑。

由于两个线程都在等待对方释放资源，导致它们都无法继续执行，从而形成了死锁。