Java 中的锁可以分为几种不同的类型,每种锁都有其特定的用途和使用场景。以下是一些常见的锁类型:
1. **synchronized 关键字**:
- 这是 Java 中最基本的同步机制,可以用来同步线程对共享资源的访问。
2. **ReentrantLock(可重入锁)**:
- `java.util.concurrent.locks.ReentrantLock` 提供了一种比 `synchronized` 更灵活的锁定机制,支持尝试非阻塞获取锁、可中断的锁获取、超时获取锁以及公平性(按照线程请求锁的顺序来获取锁)。
3. **ReadWriteLock(读写锁)**:
- `java.util.concurrent.locks.ReadWriteLock` 允许多个线程同时读取同一资源,但在写入时需要独占访问。
要注意写线程饥饿问题,可以通过公平锁解决,但是会降低性能。所以在jdk1.8引入了StampedLock
读写锁在读写分离数据库架构中保证了数据的一致性。
4. **StampedLock**:
- 一个相对于 `ReadWriteLock` 的改进版本,提供了乐观读锁和悲观写锁,可以减少锁争用。
StampedLock是不可重入锁
5. **CountDownLatch(倒计时锁)**:
- 允许一个或多个线程等待一组操作在其他线程中完成。
public class TestCountDownLatch {
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
CountDownLatch countDownLatch = new CountDownLatch(5);
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
try {
System.out.println("游戏5秒后开始执行");
lock.notifyAll();
lock.wait();
countDownLatch.await();
System.out.println("游戏正式开始。。。。。");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
try {
System.out.println("-------------------");
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 5; i > 0; i--) {
System.out.println("游戏开始倒计时" + i + "秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
countDownLatch.countDown();
}
lock.notify();
}
}
});
thread2.start();
TimeUnit.MILLISECONDS.sleep(1);
thread.start();
}
}
6. **CyclicBarrier(循环屏障)**:
- 允许多个线程相互等待,直到所有线程都到达某个公共屏障点。
`CyclicBarrier` 在多线程并发编程中有多种应用场景,以下是一些常见的例子:
1. **分阶段测试**:
在性能测试中,可能需要一组线程同时开始执行任务。使用 `CyclicBarrier` 可以确保所有线程在开始工作前同步。
2. **数据加载**:
当一个应用需要在启动时加载大量数据,而这些数据加载可以并行处理,可以使用 `CyclicBarrier` 来同步所有数据加载线程,确保它们在继续处理前完成加载。
3. **并行计算**:
在并行计算任务中,如果多个线程需要处理数据的不同部分,可以使用 `CyclicBarrier` 来等待所有线程完成它们的计算部分,然后汇总结果。
4. **游戏开发**:
在多玩家游戏中,可能需要所有玩家都准备好后才能开始游戏。`CyclicBarrier` 可以用来等待所有玩家加载完成并到达起跑线。
5. **分布式任务执行**:
在分布式系统中,如果需要多个节点或服务完成各自的任务部分,然后统一执行下一步,可以使用 `CyclicBarrier` 来同步这些节点的操作。
6. **资源分配**:
当一组线程需要分配资源,并且必须等待所有线程都分配完成后才能继续执行,`CyclicBarrier` 可以用来实现这种同步。
7. **并行数据处理**:
在数据处理应用中,如果数据被分割成多个块,并且需要并行处理这些数据块,可以使用 `CyclicBarrier` 来同步所有处理线程。
8. **初始化操作**:
在多线程应用启动时,可能需要执行一些初始化操作,如建立数据库连接或加载配置信息。`CyclicBarrier` 可以用来等待所有初始化操作完成。
9. **模拟并发用户**:
在模拟多个用户同时访问系统的场景中,`CyclicBarrier` 可以用来同步用户的登录或其他操作,以模拟高并发情况。
10. **批量处理**:
在需要批量处理多个任务,并且这些任务可以并行执行的场景中,`CyclicBarrier` 可以用来同步任务的开始和结束。
11. **科学计算**:
在科学计算或数值模拟中,可能需要多个线程执行计算的不同部分,然后汇总中间结果。`CyclicBarrier` 可以用来同步这些线程。
`CyclicBarrier` 的灵活性使其成为多线程同步中一个非常有用的工具,尤其是在需要固定数量的线程协同工作的场景中。
public class TestCyclicBarrier {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
@Override
public void run() {
System.out.println("所有线程都达到了屏障点,所有线程继续执行");
}
});
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
String name = Thread.currentThread().getName();
//屏障之前的业务代码
System.out.println(name+"到达了屏障点");
try {
cyclicBarrier.await();
System.out.println(name+"继续执行");
} catch (BrokenBarrierException | InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
}
7. **Semaphore(信号量)**:
- 控制一定数量的线程同时访问某个特定资源。
import java.util.concurrent.Semaphore;
public class SemaphoreExample {
public static void main(String[] args) {
final Semaphore semaphore = new Semaphore(3); // 允许最多3个线程同时访问资源
// 创建线程共享资源
class SharedResource {
public void useResource() {
try {
semaphore.acquire(); // 获取许可
// 模拟资源使用时间
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " is using the resource.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release(); // 释放许可
}
}
}
// 创建并启动多个线程
for (int i = 0; i < 6; i++) {
new Thread(new Runnable() {
public void run() {
((SharedResource) new SharedResource()).useResource();
}
}).start();
}
}
}
8. **Phaser**:
- 是 `CyclicBarrier` 和 `CountDownLatch` 的综合扩展,用于多阶段的同步。
9. **Exchanger(交换器)**:
- 用于两个线程之间在相遇时交换数据。
10. **Condition(条件对象)**:
- 与 `Lock` 接口一起使用,允许线程在某些条件下挂起,直到其他线程满足条件。
11. **LockSupport**:
- 提供了基本的线程阻塞和唤醒功能,用于构建同步组件。
12. **java.util.concurrent包中的其他锁**:
- 例如 `ConcurrentHashMap` 中的分段锁等。
这些锁在 Java 并发编程中非常有用,它们帮助开发者处理多线程环境中的同步问题,提高程序的性能和线程安全。选择哪种锁取决于具体的应用场景和性能要求。
AQS(AbstractQueuedSynchronizer)是 Java 中一个用于构建锁和其他同步器的框架。它使用了一个双向队列来管理线程的同步状态,这个队列被称为“同步队列”。以下是 AQS 队列的一些关键特性:
1. **FIFO 结构**:
- AQS 使用一个双向队列来维护线程的等待顺序,确保线程按照先来先服务(FIFO)的原则获取锁。
2. **头尾指针**:
- 队列有 head 和 tail 两个指针,分别指向队列的第一个和最后一个节点。
3. **节点封装**:
- 每个等待锁的线程都被封装在一个节点(Node)对象中,节点之间通过 prev 和 next 指针相连。
4. **共享模式**:
- AQS 支持两种模式:独占模式和共享模式。在独占模式下,一次只能有一个线程持有锁;在共享模式下,可以有多个线程持有锁。
5. **线程状态**:
- 节点中的线程状态(state)用于标识线程是否被阻塞、是否在等待队列中、是否已经获取了锁等。
6. **锁获取**:
- 当一个线程尝试获取锁时,AQS 会创建一个节点并将其添加到队列末尾,然后尝试获取锁。如果获取失败,线程将被阻塞。
7. **锁释放**:
- 当线程释放锁时,AQS 会检查等待队列中的下一个节点,如果存在,将其唤醒并尝试将其移动到队列头部,使其有机会获取锁。
8. **中断处理**:
- AQS 支持线程中断,当一个线程在等待锁时被中断,它可以响应中断并退出等待队列。
9. **条件变量**:
- AQS 可以与 `Condition` 对象配合使用,实现更灵活的条件等待和通知机制。
10. **模板方法**:
- AQS 提供了一系列模板方法(如 `tryAcquire`、`tryRelease`、`tryAcquireShared` 等),子类需要实现这些方法来定义同步器的具体行为。
11. **可扩展性**:
- 通过继承 AQS 并实现其模板方法,可以构建各种自定义的同步器,如 `ReentrantLock`、`Semaphore`、`CountDownLatch` 等。
AQS 队列是 Java 并发编程中一个非常强大的工具,它为构建高性能的同步器提供了基础。通过理解 AQS 的工作原理,开发者可以更好地利用 Java 提供的并发工具,或者创建满足特定需求的自定义同步器。
CLH队列锁(Craig-Landin-Hagersten Queue Lock)是一种基于单向链表的自旋锁,它提供了一种公平的锁机制,确保了先到先服务的原则。在Java中,`AbstractQueuedSynchronizer`(AQS)的实现就是基于CLH队列锁变种的。
**CLH队列锁的实现原理**:
1. 每个线程在尝试获取锁时会创建一个节点(`QNode`),并将其加入到队列的尾部。
2. 线程通过自旋等待前驱节点释放锁,锁的状态由节点中的`locked`字段表示。
3. 使用`AtomicReference`维护队列的尾指针,确保线程安全地更新队尾。
4. 线程通过`ThreadLocal`存储当前节点和前驱节点的引用,避免线程间的数据竞争。
**Java实现示例**:
```java
public class CLHLock implements Lock {
private final AtomicReference<QNode> tail = new AtomicReference<>(new QNode());
private final ThreadLocal<QNode> myNode = ThreadLocal.withInitial(QNode::new);
private final ThreadLocal<QNode> myPred = new ThreadLocal<>();
public void lock() {
QNode node = myNode.get();
node.locked = true;
QNode pred = tail.getAndSet(node);
myPred.set(pred);
while (pred.locked) {
// 自旋等待
}
}
public void unlock() {
QNode node = myNode.get();
node.locked = false;
myNode.set(myPred.get());
}
private static class QNode {
volatile boolean locked = false;
}
}
```
**使用场景**:
CLH队列锁适用于锁占用时间短且需要保证公平性的场合。在Java并发编程中,`ReentrantLock`、`ReentrantReadWriteLock`等同步组件在底层都依赖于AQS实现,间接使用了CLH队列锁的思想。
**优势**:
- **公平性**:确保了先到先服务的原则,避免了线程饥饿。
- **高效性**:基于自旋锁,减少了线程切换的开销。
- **可扩展性**:动态调整队列长度,适应不同并发场景。
**缺点**:
- **CPU资源消耗**:在高并发环境下,大量线程自旋可能消耗大量CPU资源。
- **自旋等待**:如果锁被长时间占用,线程会空转,造成资源浪费。
**总结**:
CLH队列锁是一种高效的并发控制机制,通过自旋等待和队列管理,实现了公平且高性能的锁机制。在Java中,AQS作为构建锁和其他同步器的基础,其内部的锁队列就是基于CLH队列锁的原理实现的 。