请用java写一个公平锁
时间: 2023-09-20 20:05:41 浏览: 48
### 回答1:
在 Java 中,可以使用 `java.util.concurrent.locks.ReentrantLock` 类来实现公平锁。使用方法如下:
```
import java.util.concurrent.locks.ReentrantLock;
public class FairLock {
private ReentrantLock lock;
public FairLock(boolean fair) {
lock = new ReentrantLock(fair);
}
public void lock() {
lock.lock();
}
public void unlock() {
lock.unlock();
}
}
```
使用时,需要在构造函数中传入一个 `boolean` 类型的参数,若为 `true`,则表示使用公平锁,否则表示使用非公平锁。
使用公平锁时,线程会按照请求锁的顺序来获取锁,这意味着,如果一个线程在另一个线程之前请求了锁,那么请求锁的线程将会先获得锁。
### 回答2:
在Java中,我们可以使用ReentrantLock类来实现一个公平锁。ReentrantLock是Lock接口的一个实现,它提供了可重入的互斥锁,同时也支持公平性。
以下是一个使用ReentrantLock实现的公平锁的示例代码:
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class FairLockExample {
private final Lock lock = new ReentrantLock(true); // 创建一个公平锁
public void doSomething() {
lock.lock(); // 获取锁
try {
// 在这里执行需要保护的代码段
} finally {
lock.unlock(); // 释放锁
}
}
public static void main(String[] args) {
FairLockExample example = new FairLockExample();
// 创建多个线程来演示锁的公平性
Thread thread1 = new Thread(() -> example.doSomething());
Thread thread2 = new Thread(() -> example.doSomething());
Thread thread3 = new Thread(() -> example.doSomething());
thread1.start();
thread2.start();
thread3.start();
}
}
```
在上述代码中,我们使用ReentrantLock的构造函数创建了一个公平锁,通过将参数设置为true来启用公平性。在doSomething方法中,我们首先通过lock()方法获取锁,在需要保护的代码段中执行相应的操作,最后使用unlock()方法释放锁。
通过多次运行上述代码,我们可以看到线程按照创建的先后顺序依次获取到锁。
使用公平锁可以保证多个线程按照创建的顺序逐个获取锁,提供了一定的公平性保证。
### 回答3:
公平锁是指多个线程按照其申请锁的顺序来获取锁的一种锁机制。使用Java可以通过ReentrantLock类来实现公平锁。
首先,我们需要创建一个ReentrantLock对象并指定其为公平锁:
ReentrantLock fairLock = new ReentrantLock(true);
在多个线程需要获取锁的地方,可以使用以下代码来获取锁:
fairLock.lock();
在线程执行完需要同步的操作之后,需要释放锁,可以使用以下代码:
fairLock.unlock();
这样,多个线程在争用锁的时候,会按照申请锁的先后顺序来获取锁,保证了线程的公平性。
下面是一个使用公平锁的简单示例代码:
import java.util.concurrent.locks.ReentrantLock;
public class FairLockExample {
private static ReentrantLock fairLock = new ReentrantLock(true);
private static int count = 0;
public static void main(String[] args) {
Thread thread1 = new Thread(new Worker());
Thread thread2 = new Thread(new Worker());
thread1.start();
thread2.start();
}
static class Worker implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
fairLock.lock();
try {
count++;
System.out.println(Thread.currentThread().getName() + " count = " + count);
} finally {
fairLock.unlock();
}
}
}
}
}
在该示例中,创建了两个线程并共享了一个计数器count,每个线程执行10次自增操作。在每次自增操作前,线程会先获取锁,然后执行自增操作并输出结果,最后释放锁。
经过运行测试,可以发现两个线程按照申请锁的先后顺序来获取锁,并且每个线程执行完自增操作后才会释放锁,保证了线程的公平性。