Java并发编程中的锁问题案例

原创偏执的太偏执、 2024-12-01 23:06 11阅读 0赞

在Java并发编程中，锁问题是常见的并发控制手段。以下是一个简单的锁问题案例：

```java
// 创建一个共享资源（例如：counter）
public class Counter {
    private int count = 0;

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

// 提供一个方法来获取当前的计数器值
    public synchronized int getCount() {
        return count;
    }
}

// 主程序，线程A和B分别尝试增加计数器
public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

// 创建两个线程
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment(); // 线程A尝试增加计数器
                try {
                    // 模拟长时间操作，防止阻塞主线程
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment(); // 线程B尝试增加计数器
                try {
                    // 模拟长时间操作，防止阻塞主线程
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

// 启动线程
        thread1.start();
        thread2.start();

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

System.out.println("Counter count: " + counter.getCount()); // 输出最终计数器值
    }
}
```

在这个例子中，两个并发线程A和B尝试增加共享的`Counter`对象。由于Java的`synchronized`关键字，每个方法对同一个`Counter`实例执行加锁，确保在同一时刻只有一个线程在操作。

运行这个程序，你会看到每个线程在完成5次尝试后打印出当前计数器值。最终结果将是50（5 * 10）作为计数器的累计值。