Java并发编程中的锁机制详解实例

原创桃扇骨 2024-11-06 18:05 34阅读 0赞

Java并发编程中的锁机制是用于控制多个线程对共享资源访问的一种同步机制，以防止数据不一致和竞态条件。以下是一些Java中常见的锁机制及其使用实例：

###1. synchronized关键字`synchronized`关键字可以用来修饰方法或者代码块，确保同一时间只有一个线程执行该段代码。

**实例：**

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

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

public synchronized int getCount() {
 return count;
 }
}
```在这个例子中，`increment`和`getCount`方法都被`synchronized`修饰，确保了对`count`变量的访问是线程安全的。

###2. ReentrantLock`ReentrantLock`是一个可重入的互斥锁，提供了与`synchronized`关键字类似的基本行为和语义，但它提供了更灵活的加锁和解锁操作。

**实例：**

```javaimport java.util.concurrent.locks.ReentrantLock;

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

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

public int getCount() {
lock.lock();
 try {
 return count;
} finally {
lock.unlock();
 }
 }
}
```在这个例子中，我们使用`ReentrantLock`来控制对`count`变量的访问。

###3. ReadWriteLock`ReadWriteLock`允许多个读操作同时进行，但在写操作时会阻塞所有的读和写操作。

**实例：**

```javaimport java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Counter {
 private final ReadWriteLock lock = new ReentrantReadWriteLock();
 private int count =0;

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

public int getCount() {
lock.readLock().lock();
 try {
 return count;
} finally {
lock.readLock().unlock();
 }
 }
}
```在这个例子中，`increment`方法使用写锁，而`getCount`方法使用读锁。

###4. StampedLock`StampedLock`是一个新型的锁机制，它支持乐观读锁和悲观读锁，以及写锁。

**实例：**

```javaimport java.util.concurrent.locks.StampedLock;

public class Counter {
 private final StampedLock stampedLock = new StampedLock();
 private int count =0;

public void increment() {
 long stamp = stampedLock.writeLock();
 try {
 count++;
} finally {
 stampedLock.unlockWrite(stamp);
 }
 }

public int getCount() {
 long stamp = stampedLock.tryOptimisticRead();
int current;
if (stampedLock.validate(stamp)) {
 current = count;
} else {
 stamp = stampedLock.readLock();
 try {
 current = count;
} finally {
 stampedLock.unlockRead(stamp);
 }
 }
 return current;
 }
}
```在这个例子中，`increment`方法使用写锁，而`getCount`方法首先尝试乐观读锁，如果失败则使用悲观读锁。

这些锁机制的选择取决于具体的应用场景和性能要求。在实际开发中，合理选择和使用锁机制是非常重要的。