实例解析：Java多线程并发问题案例

原创骑猪看日落 2024-12-11 02:42 9阅读 0赞

在Java编程中，多线程并发问题是非常常见的。以下是一些具体的案例：

1. **竞态条件**：多个线程同时访问和修改共享资源，会导致数据不一致。例如：

```java
public class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
    }

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new IllegalStateException("Counter underflow");
        }
    }

public synchronized int getCount() {
        return count;
    }
}
```

2. **死锁**：当两个或更多线程在执行过程中，因争夺资源而造成的一种互相等待的现象。例如：

```java
public class DeadLockExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void method1() {
        synchronized (lock1) {
            // do something here
            try {
                Thread.sleep(1000); // simulate long operation
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 1 finished");

// lock2 must be acquired before unlocking lock1
            synchronized (lock2) {
                lock2.notifyAll(); // wake up all waiting threads on lock2
            }
        }
    }

public void method2() {
        synchronized (lock2) {
            while (!lock2.isHeldByCurrentThread()) { // check if currently holding lock2
                System.out.println("Method 2 waiting for lock2");
                try {
                    Thread.sleep(500); // short sleep to avoid blocking
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

lock2.lock(); // acquire lock2

System.out.println("Method 2 acquired lock2");

// release lock1 before releasing lock2
            synchronized (lock1) {
                lock1.notifyAll(); // wake up all waiting threads on lock1
                lock1.unlock(); // release lock1
            }
        }
    }

public static void main(String[] args) {
        DeadLockExample deadlockExample = new DeadLockExample();
        Thread thread1 = new Thread(deadlockExample::method1));
        Thread thread2 = new Thread(deadlockExample::method2));

thread1.start(); // start thread 1
        thread2.start(); // start thread 2

try {
            thread1.join(); // wait for thread 1 to finish before exiting the main method
            thread2.join(); // wait for thread 2 to finish before exiting the main method
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上案例展示了线程间的死锁问题，通过模拟多线程执行过程，可以更直观地理解并避免此类问题。