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

原创淩亂°似流年 2024-10-20 04:12 45阅读 0赞

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

1. **数据不一致（race condition）**：多个线程同时访问和修改共享资源，可能会导致结果错误。

例如：
```java
class Counter {
    int count;
    synchronized void increment() {
        count++;
        notifyAll(); // 线程等待通知后继续执行
    }
}

// 多个线程同时尝试增加计数器
new Thread(() -> new Counter().increment()).start();
new Thread(() -> new Counter().increment()).start();
```
2. **死锁（Deadlock）**：两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行。

例如：
```java
class Resource {
    boolean locked;
    synchronized void lock() {
        if (!locked) {
            locked = true;
            notifyAll(); // 线程等待通知后继续执行
        } else {
            throw new IllegalStateException("Resource already locked");
        }
    }
    synchronized void unlock() {
        if (locked) {
            locked = false;
            notifyAll(); // 线程等待通知后继续执行
        } else {
            throw new IllegalStateException("Resource not locked");
        }
    }
}

// 死锁示例
class ThreadA extends Thread {
    Resource resource;

public ThreadA(Resource resource) {
        this.resource = resource;
        start();
    }

@Override
    public void run() {
        resource.lock();
        System.out.println("Thread A: Locking resource");
        // 线程A等待ThreadB释放资源后继续执行
        try {
            resource.unlock();
        } catch (IllegalStateException e) {
            System.out.println("Thread A: Error unlocking resource, re-locking...");
            resource.lock();
        }
        System.out.println("Thread A: Unlocking and exiting resource");
    }
}

class ThreadB extends Thread {
    Resource resource;

public ThreadB(Resource resource) {
        this.resource = resource;
        start();
    }

@Override
    public void run() {
        resource.lock();
        System.out.println("Thread B: Locking resource");
        // 线程B释放资源后等待ThreadA继续执行
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread B: Exiting resource and releasing lock");
        resource.unlock();
    }
}

public class Main {
    public static void main(String[] args) {
        Resource resource = new Resource();
        ThreadA threadA = new ThreadA(resource);
        ThreadB threadB = new ThreadB(resource);

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

// 等待所有线程完成
        try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```
这个例子中，线程A和线程B分别试图锁住资源并执行相关操作。由于它们的执行顺序是互锁（互斥条件），这就导致了死锁现象：两个线程相互等待对方释放资源，而无法继续各自的操作。