异常处理不当，Java中多线程并发问题实例

原创向右看齐 2024-10-08 03:03 40阅读 0赞

在Java中，多线程并发问题主要体现在共享资源的访问和控制上。以下是一个简单的例子：

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

// 提供一个方法来增加计数
    public synchronized void increment() {
        count++;
    }

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

// 多线程并发问题实例
public class ConcurrentExample {
    private SharedResource sharedResource;

public ConcurrentExample(int initialCount) {
        this.sharedResource = new SharedResource();
        sharedResource.increment(); // 初始增加计数
        if (initialCount != sharedResource.getCount()) { // 比较初始和当前计数
            throw new RuntimeException("Initial count and current count do not match!");
        }
    }

public void thread1() {
        for (int i = 0; i < 10; i++) {
            try {
                sharedResource.increment();
                System.out.println("Thread 1 incremented count: " + sharedResource.getCount());
            } catch (Exception e) {
                // 处理异常
                System.out.println("Error in Thread 1 increment: " + e.getMessage());
            }
        }
    }

public void thread2() {
        for (int i = 0; i < 10; i++) {
            try {
                sharedResource.increment();
                // 这里假设另一个线程（thread3）也尝试增加计数
                if (i == 5 && !sharedResource.isLocked()) { // 模拟线程3的条件
                    System.out.println("Thread 2 is acquiring lock on count.");
                    sharedResource.lock(); // 获取锁，防止其他线程修改计数
                    try {
                        // 此时thread2可以安全地增加计数了
                        sharedResource.increment();
                        System.out.println("Thread 2 incremented count with lock: " + sharedResource.getCount());
                        // 在这里假设thread3在尝试加锁之前成功完成了计数操作
                        if (sharedResource.getCount() != thread3ExpectedCount) {
                            System.out.println("Error in Thread 2 increment with lock: Expected count does not match actual count!");
                            break;
                        }
                    } catch (Exception e) {
                        System.out.println("Error in Thread 2 increment with lock: " + e.getMessage());
                        break;
                    } finally {
                        // 无论是否需要，都需要释放锁
                        if (sharedResource.isLocked()) {
                            System.out.println("Thread 2 is releasing lock on count.");
                            sharedResource.unlock(); // 解锁
                        }
                    }
                } catch (Exception e) {
                    System.out.println("Error in Thread 2 increment: " + e.getMessage());
                    break;
                }
            } catch (Exception e) {
                System.out.println("Error in Thread 2 loop: " + e.getMessage());
                break;
            }
        }
    }

public static void main(String[] args) throws InterruptedException {
        ConcurrentExample example = new ConcurrentExample(1);
        Thread thread1 = new Thread(example::thread1));
        Thread thread2 = new Thread(example::thread2));

thread1.start();
        thread2.start();

// 等待线程完成
        thread1.join();
        thread2.join();

System.out.println("Thread 1 incremented count: " + example.sharedResource.getCount());
        System.out.println("Thread 2 incremented count with lock: " + example.sharedResource.getCount());
    }
}
```

这个例子展示了多个线程同时访问和修改共享资源（在这个案例中是`SharedResource`类的计数器）可能导致的问题。在实际应用中，我们需要采取适当的并发控制机制来防止这种情况的发生。