Java多线程并发常见问题实例

原创素颜马尾好姑娘i 2024-09-24 09:30 84阅读 0赞

在Java多线程编程中，常见的并发问题包括但不限于以下几种：

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

```java
Thread t1 = new Thread(() -> {
    lock1();
    lock2(); // 这里会阻塞直到lock2()被释放
}));
Thread t2 = new Thread(() -> {
    lock2();
    lock1(); // 这里也会阻塞直到lock1()被释放
});
t1.start();
t2.start();
```

2. **资源争抢**：多个线程同时访问和修改共享资源，可能会导致数据不一致或死锁。例如：

```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 RuntimeException("Can't decrement counter below zero.");
        }
    }

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

3. **线程同步问题**：如上所述，多线程对共享资源的访问必须进行适当的控制，否则可能导致数据不一致或死锁。例如：

```java
public class CounterWithLock {
    private int count;
    private Lock lock = new ReentrantLock();

public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

public void decrement() throws InterruptedException {
        lock.lock();
        try {
            if (count > 0) {
                count--;
                // 在这里可以添加一些检查逻辑
                // 这里假设没有错误，直接释放锁
                lock.unlock();
                return;
            } else {
                throw new RuntimeException("Can't decrement counter below zero.");
            }
        } finally {
            lock.unlock();
        }
    }

public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}
```

在实际编程中，需要根据具体需求和并发场景来设计多线程程序，并避免上述问题。