java 有哪些锁

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队列锁的原理实现的  。