从例子看：Java的多线程并发问题

原创我会带着你远行 2024-12-02 15:15 13阅读 0赞

Java多线程并发问题主要体现在资源竞争、同步机制和异常处理等方面。以下是一个简单的例子，展示了Java多线程并发可能遇到的问题：

```java
// 创建两个共享变量
class Counter {
    int count = 0;

synchronized void increment() {
        count++;
        notifyAll(); // 通知其他线程
    }

synchronized int decrement() {
        if (count > 0) {
            count--;
            wait(); // 等待被唤醒
            return count;
        } else {
            throw new IllegalArgumentException("Counter is already at zero.");
        }
    }
}

// 创建两个线程，对共享变量进行操作
public class ConcurrentExample {

private Counter counter;

public ConcurrentExample() {
        counter = new Counter();
    }

// 线程1，递增
    public void threadIncrement() {
        while (true) {
            counter.increment(); // 问题：可能会出现死锁
            try {
                // 如果线程被中断，则需要捕获并处理中断
                Thread.sleep(100); // 模拟操作耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
                // 处理中断，如结束当前任务等
                break;
            }
        }
    }

// 线程2，递减
    public void threadDecrement() {
        while (true) {
            counter.decrement(); // 问题：可能会出现死锁
            try {
                // 模拟操作耗时
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
                // 处理中断，如结束当前任务等
                break;
            }
        }
    }

public static void main(String[] args) {
        ConcurrentExample example = new ConcurrentExample();
        Thread threadIncrement = new Thread(example::threadIncrement);
        Thread threadDecrement = new Thread(example::threadDecrement);

// 启动线程
        threadIncrement.start();
        threadDecrement.start();

// 等待所有线程执行完毕
        try {
            threadIncrement.join();
            threadDecrement.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，`Counter`类的两个方法`increment`和`decrement`用于操作共享变量。当两个线程同时修改这个共享变量时，就可能导致死锁问题。

解决这类问题的方法通常包括使用锁（synchronized关键字）、原子操作、信号量或者其他同步机制。并且在设计并发程序时要避免循环等待等问题。