Java并发编程中的锁机制使用示例

原创た入场券 2024-10-17 15:06 42阅读 0赞

在Java的并发编程中，锁是一种同步机制，用于控制对共享资源的访问。以下是一个简单的锁机制使用示例：

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SharedResource {
    private int count = 0;

public synchronized void increment() {
        count++;
        notifyAll(); // 通知所有等待的线程
    }

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

public class LockExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

// 创建锁对象
        Lock lock = new ReentrantLock();

// 线程1：增加计数
        Thread thread1 = new Thread(() -> {
            try {
                lock.lock(); // 获取锁
                resource.increment();
            } finally {
                lock.unlock(); // 释放锁
            }
        }));

// 线程2：获取当前计数
        Thread thread2 = new Thread(() -> {
            try {
                lock.lock(); // 获取锁
                int count = resource.getCount();
                System.out.println("Thread 2: Count is " + count);
            } finally {
                lock.unlock(); // 释放锁
            }
        }));

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

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

System.out.println("Final Count: " + resource.getCount());
    }
}
```

在这个示例中，我们创建了一个共享资源类`SharedResource`，它有一个可以被多个线程同时修改的计数器。

然后在主线程中，我们创建了两个线程，分别执行增加计数和获取当前计数的操作。每个操作都需要先获得锁，然后修改资源，最后释放锁。

最后，我们在所有线程都完成执行后，输出最终的计数器值。