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

原创骑猪看日落 2024-11-13 23:52 2阅读 0赞

Java并发编程中，锁机制是控制多个线程对共享资源访问的一种方式，以保证数据的一致性和线程安全。Java提供了多种锁机制，包括内置锁（synchronized关键字）、显式锁（Lock接口及其实现类，如ReentrantLock）等。下面我将分别给出使用内置锁和显式锁的示例。

###1. 使用内置锁（synchronized关键字）

内置锁是Java中最基本的锁机制，通过synchronized关键字实现。它可以修饰方法或者代码块。

#### 示例：修饰方法```javapublic class Counter {
 private int count =0;

public synchronized void increment() {
 count++;
 }

public synchronized int getCount() {
 return count;
 }
}
```在这个例子中，`increment`和`getCount`方法都被`synchronized`修饰，这意味着同一时间只有一个线程可以执行这两个方法中的任意一个。

#### 示例：修饰代码块```javapublic class Counter {
 private int count =0;
 private final Object lock = new Object();

public void increment() {
 synchronized (lock) {
 count++;
 }
 }

public int getCount() {
 synchronized (lock) {
 return count;
 }
 }
}
```在这个例子中，我们使用一个对象`lock`作为锁对象，通过`synchronized (lock)`修饰代码块，同样可以保证同一时间只有一个线程可以执行`increment`和`getCount`方法中的代码块。

###2. 使用显式锁（Lock接口）

Java并发包`java.util.concurrent.locks`提供了更灵活的锁机制，如`ReentrantLock`。

#### 示例：使用ReentrantLock```javaimport java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
 private int count =0;
 private final Lock lock = new ReentrantLock();

public void increment() {
lock.lock();
 try {
 count++;
} finally {
lock.unlock();
 }
 }

public int getCount() {
lock.lock();
 try {
 return count;
} finally {
lock.unlock();
 }
 }
}
```在这个例子中，我们使用`ReentrantLock`作为锁对象。通过`lock.lock()`获取锁，`lock.unlock()`释放锁。注意，我们使用`try-finally`块确保即使在发生异常的情况下也能释放锁。

###总结- **内置锁（synchronized）**：简单易用，但功能有限，不能响应中断、超时等。
- **显式锁（Lock接口）**：更灵活，支持响应中断、超时等特性，适用于更复杂的并发场景。

根据具体需求选择合适的锁机制，以实现线程安全。