Java并发编程常见问题及示例

原创蔚落 2024-09-15 05:45 11阅读 0赞

在Java并发编程中，常见的问题包括线程安全、死锁、资源泄露、优先级反转等。以下是一些具体的示例：

1. 线程不安全：如果一个类的两个方法互操作，并且没有正确同步，就可能导致线程不安全。

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

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

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

// 获取当前计数
    public synchronized int getCount() {
        return count;
    }
}
```

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

```java
class BankAccount {
    private String accountNo;
    private double balance;

// 不同步方法
    public void deposit(double amount) {
        if (amount >= 0) {
            balance += amount;
        }
    }

public void withdraw(double amount) {
        if (amount >= 0 && amount <= balance) {
            balance -= amount;
        } else {
            throw new IllegalArgumentException("Amount withdrawn is not within the available balance.");
        }
    }

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

public double getBalance() {
        return balance;
    }

// 设置账户信息，不推荐同步调用
    // synchronized void setAccountNo(String newAccountNo) {
    //     accountNo = newAccountNo;
    // }
}
```

3. 资源泄露：当一个线程使用完资源后，没有正确释放这些资源，导致这些资源无法被其他线程利用，这种情况被称为资源泄露。

```java
class ResourceLeakExample {
    private static final int COUNT = 1000;

public static void main(String[] args) {
        // 创建多个线程并发执行
        for (int i = 0; i < COUNT; i++) {
            new Thread(() -> performOperation(i)).start();
        }
    }

// 模拟耗时操作，这里使用Thread.sleep方法来模拟
    private static void performOperation(int index) {
        try {
            // 耗时操作，这里设置为1秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Thread index: " + index);
    }
}
```

以上就是Java并发编程中常见问题及示例。