解决Java中常见的并发问题：基于Locks的实现

原创缺乏、安全感 2024-11-11 16:57 5阅读 0赞

在Java中，处理并发问题时，`Locks` 是一种常用的同步机制，它提供了比 `synchronized` 更灵活的锁定机制。以下是一些基于 `Locks` 的实现来解决常见的并发问题：

###1.互斥锁（ReentrantLock）

`ReentrantLock` 是一个可重入的互斥锁，它允许一个线程多次获得同一个锁。

```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() {
 return count;
 }
}
```###2.读写锁（ReadWriteLock）

`ReadWriteLock`允许多个读操作同时进行，但写操作是互斥的。

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

public class SharedResource {
 private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
 private int data;

public void updateData(int newData) {
readWriteLock.writeLock().lock();
 try {
data = newData;
} finally {
readWriteLock.writeLock().unlock();
 }
 }

public int getData() {
readWriteLock.readLock().lock();
 try {
 return data;
} finally {
readWriteLock.readLock().unlock();
 }
 }
}
```###3.条件变量（Condition）

`Condition`允许线程在某些条件不满足时挂起，并在条件满足时被唤醒。

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

public class BoundedBuffer {
 private final ReentrantLock lock = new ReentrantLock();
 private final Condition notFull = lock.newCondition();
 private final Condition notEmpty = lock.newCondition();
 private final Object[] items = new Object[100];
 private int putptr, takeptr, count;

public void put(Object x) throws InterruptedException {
lock.lock();
 try {
 while (count == items.length) {
 notFull.await();
 }
 items[putptr] = x;
if (++putptr == items.length) putptr =0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
 }
 }

public Object take() throws InterruptedException {
lock.lock();
 try {
 while (count ==0) {
notEmpty.await();
 }
Object x = items[takeptr];
if (++takeptr == items.length) takeptr =0;
--count;
 notFull.signal();
 return x;
} finally {
lock.unlock();
 }
 }
}
```###4.公平锁（Fair Locks）

`ReentrantLock`可以被构造为公平锁，这意味着等待时间最长的线程将获得锁。

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

public class FairLockExample {
 private final ReentrantLock fairLock = new ReentrantLock(true);

public void doSomething() {
 fairLock.lock();
 try {
//执行任务} finally {
 fairLock.unlock();
 }
 }
}
```###5.定时锁（tryLock）

`tryLock` 方法尝试获取锁，如果锁不可用，它不会阻塞线程，而是立即返回 `false`。

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

public class TryLockExample {
 private final ReentrantLock lock = new ReentrantLock();

public void doSomething() {
if (lock.tryLock()) {
 try {
//执行任务} finally {
lock.unlock();
 }
} else {
//处理锁不可用的情况 }
 }
}
```使用 `Locks`时，务必确保在 `finally`块中释放锁，以避免死锁。这些是一些基本的 `Locks` 实现，用于解决Java中的并发问题。