理解Java多线程编程中的锁机制实例

原创怼烎@ 2024-09-13 05:15 72阅读 0赞

在Java多线程编程中，锁机制（Lock）是一种同步手段，用于控制对共享资源的访问。

以下是一个简单的例子来理解锁的使用：

假设我们有一个共享资源——一个整数变量count，多个线程同时修改这个变量可能会导致数据不一致的问题。

```java
class Counter {
    private int count = 0;

public synchronized void increment() {
        count++;
        notifyAll(); // 唤醒等待的线程
    }

public synchronized int getCount() {
        return count;
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        Counter counter = new Counter();

// 创建两个线程，分别尝试增加和获取count
        Thread threadIncrement1 = new Thread(() -> {
            while (true) { // 循环等待锁的释放
                try {
                    if (counter.getCount() == 0) {
                        System.out.println("Thread 1: Incrementing count for the first time.");
                    }
                    counter.increment(); // 增加count，但需要获取锁
                    break; // 执行完增加操作后，释放锁并退出循环
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break; // 线程中断时，退出循环
                }
            }
        }));

Thread threadIncrement2 = new Thread(() -> {
            while (true) { // 循环等待锁的释放
                try {
                    if (counter.getCount() == 0) {
                        System.out.println("Thread 2: Incrementing count for the first time.");
                    }
                    counter.increment(); // 增加count，但需要获取锁
                    break; // 执行完增加操作后，释放锁并退出循环
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break; // 线程中断时，退出循环
                }
            }
        }));

threadIncrement1.start(); // 启动线程1
        threadIncrement2.start(); // 启动线程2

try {
            threadIncrement1.join(); // 等待线程1完成
            threadIncrement2.join(); // 等待线程2完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

在这个例子中，我们创建了两个线程，分别尝试增加count。但是，由于Java的单例锁（Synchronized）机制，当一个线程在访问共享资源`counter.increment()`时，其他线程必须等待这个操作完成，才能获取到锁并进行操作。

通过上述代码，你可以看到多线程中锁的作用，以及如何避免数据不一致的问题。