Java并发编程：锁的问题示例

原创蔚落 2024-09-20 21:36 5阅读 0赞

在Java并发编程中，锁是一种机制，用于控制对共享资源的访问。当多个线程同时访问或修改一个变量时，就需要使用锁来保证数据的一致性和完整性。

以下是一个简单的锁问题示例：

```java
// 假设我们有一个共享资源
public class SharedResource {
    private int count = 0;

// 获取资源的方法，返回count的值
    public synchronized int getCount() {
        return count;
    }

// 增加资源的方法，将count递增1
    public synchronized void incrementCount() {
        count++;
    }
}

// 两个线程来操作共享资源
public class LockExample {
    private SharedResource shared;

public LockExample(SharedResource shared) {
        this.shared = shared;
    }

// 线程A：增加资源
    public Thread threadA() {
        new Thread(() -> {
            try {
                while (shared.getCount() < 5) {
                    System.out.println("Thread A: Incrementing count to " + shared.getCount());
                    shared.incrementCount();
                    if (shared.getCount() == 5) {
                        break;
                    }
                }
                System.out.println("Thread A: Count reached 5");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        })}).start();
        return threadA;
    }

// 线程B：获取资源并检查
    public Thread threadB() {
        new Thread(() -> {
            try {
                while (shared.getCount() != 5) {
                    System.out.println("Thread B: Checking count, current value is " + shared.getCount());
                    if (shared.getCount() < 5) {
                        System.out.println("Thread B: Count needs to be incremented");
                        break;
                    }
                    if (shared.getCount() > 5) {
                        System.out.println("Thread B: Count needs to be decremented");
                        break;
                    }
                }
                System.out.println("Thread B: Count reached 5, check complete");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        })}).start();
        return threadB;
    }

public static void main(String[] args) {
        SharedResource shared = new SharedResource();
        LockExample example = new LockExample(shared);
        example.threadA().join();
        example.threadB().join();
    }
}
```

在这个例子中，我们有两个线程（`threadA`和`threadB`），一个共享资源（`SharedResource`）。

线程`threadA`负责增加共享资源的计数。这是一个同步操作，锁在`incrementCount`方法上。

线程`threadB`则负责获取资源，并检查资源是否达到预期值。这也是同步操作，锁在`getCount`方法上。

主线程启动这两个线程，然后等待它们执行完毕。这样就能保证数据的完整性，避免竞态条件的发生。