Java多线程同步死锁问题实例

原创短命女 2024-11-22 00:24 4阅读 0赞

死锁是多线程编程中常见的问题，当两个或更多的线程因争夺资源而造成的一种互相等待的现象称为死锁。

下面是一个简单的Java多线程同步死锁问题实例：

```java
// 定义一个共享资源，如银行的账户
class BankAccount {
    private int accountNo;
    private int balance;

// 构造函数，初始化账户信息
    BankAccount(int accountNo, int balance) {
        this.accountNo = accountNo;
        this.balance = balance;
    }

// 获取账户信息
    int getAccountNo() {
        return accountNo;
    }

int getBalance() {
        return balance;
    }
}

// 定义两个线程，分别尝试获取另一个线程已锁定的资源
class ThreadA extends Thread {
    private BankAccount account;

ThreadA(BankAccount account) {
        this.account = account;
    }

@Override
    public void run() {
        try {
            // 获取并锁定账户资源
            account = new BankAccount(2, 0);
            synchronized (account) {
                // 执行需要锁住资源的操作
                for (int i = 1; i <= 5; i++) {
                    account.getBalance();
                }
            }

} catch (Exception e) {
            System.out.println("Thread A Exception: " + e.getMessage());
        } finally {
            // 在任何情况下，释放已锁定的资源
            if (account != null) {
                synchronized (account) {
                    account = null;
                }
            }
            System.out.println("Thread A Finished.");
        }
    }
}

class ThreadB extends Thread {
    private BankAccount account;

ThreadB(BankAccount account) {
        this.account = account;
    }

@Override
    public void run() {
        try {
            // 获取并锁定账户资源
            account = new BankAccount(1, 0);
            synchronized (account) {
                // 执行需要锁住资源的操作
                for (int i = 6; i <= 10; i++) {
                    account.getBalance();
                }
            }

} catch (Exception e) {
            System.out.println("Thread B Exception: " + e.getMessage());
        } finally {
            // 在任何情况下，释放已锁定的资源
            if (account != null) {
                synchronized (account) {
                    account = null;
                }
            }
            System.out.println("Thread B Finished.");
        }
    }
}

// 主程序，启动两个线程
public class Main {
    public static void main(String[] args) {
        BankAccount bankAccount1 = new BankAccount(1, 0);
        BankAccount bankAccount2 = new BankAccount(2, 0);

ThreadA threadA = new ThreadA(bankAccount1);
        ThreadB threadB = new ThreadB(bankAccount2);

// 启动线程
        threadA.start();
        threadB.start();

System.out.println("Main Finished.");
    }
}
```

在这个例子中，两个线程（Thread A 和 Thread B）分别尝试获取另一个线程已锁定的资源（账户）。由于死锁条件（占有并等待资源）的存在，程序会进入死锁状态，无法继续执行。