如何解决Java多线程并发问题案例

原创红太狼 2024-10-11 00:36 49阅读 0赞

在Java中，多线程并发问题主要涉及数据一致性、锁机制、死锁等问题。以下是一些具体的处理案例：

1. **同步问题：**多个线程同时访问共享资源可能导致结果不一致。例如，两个线程交替打印数字，但是可能会出现交错的问题。

```java
class Counter {
    private int count;

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            notifyAll();
            return count;
        } else {
            throw new IllegalStateException("Counter is already at zero.");
        }
    }

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

public class CounterExample {
    private static final Counter counter = new Counter();

public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    // 使主线程有机会打印
                    // 主线程不会被通知
                    // 但是，这将允许我们看到
                    // 两个线程如何交替执行
                    counter.increment();
                    System.out.println("Thread 1: " + counter.getCount());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    // 让主线程有机会打印
                    // 主线程不会被通知
                    // 这将使我们能够看到两个线程如何交替执行
                    counter.decrement();
                    System.out.println("Thread 2: " + counter.getCount());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

thread1.start();
        thread2.start();
    }
}
```

在这个例子中，我们创建了两个线程（Thread 1 和 Thread 2）来交替打印一个Counter类中的计数。通过使用`synchronized`关键字，我们可以确保在任何时候只有一个线程能够修改Counter的值。

2. **死锁：**当多个线程因争夺资源而造成的一种互相等待的现象时，就可能发生死锁问题。例如：

```java
class BankAccount {
    private int balance;

public synchronized void deposit(int amount) throws InterruptedException {
        if (amount > 0) {
            balance += amount;
            notifyAll();
        } else {
            throw new IllegalArgumentException("Deposit amount cannot be negative.");
        }
    }

public synchronized void withdraw(int amount) throws InterruptedException {
        if (amount >= 0 && balance >= amount) {
            balance -= amount;
            notifyAll();
        } else {
            throw new IllegalArgumentException("Withdrawal amount exceeds available balance.");
        }
    }

// Other methods and getters...
}

public class DeadLockExample {
    private static final BankAccount account1 = new BankAccount();
    private static final BankAccount account2 = new BankAccount();

public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            try {
                // Account 1 deposits into itself
                account1.deposit(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

Thread thread2 = new Thread(() -> {
            try {
                // Account 2 withdraws from itself to account 1
                account2.withdraw(30);
                account1.deposit(30); // Account 1 deposits the remaining amount back into itself
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

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

// Wait for threads to complete
        thread1.join();
        thread2.join();
    }
}
```

在这个例子中，两个线程（Thread 1 和 Thread 2）分别操作两个银行账户（Account 1 和 Account 2）。线程1将50元存入Account 1。线程2首先从Account 2中取出30元，然后将这30元存入Account 1。

由于线程2在操作账户之前已经从Account 2中取出了30元（存入Account 1），所以当线程1试图再次向Account 1存款时，账户已经被其他线程操作了。这就导致了两个线程互相等待的现象，形成了死锁。