说说Java锁有那些种类，以及区别

在 Java 中，有几种不同类型的锁可用于控制对共享资源的访问：

1. 对象锁：这是最常用的锁类型，可以使用 `synchronized` 关键字来获取对象锁。对象锁可以在任何时候与任何对象关联，可以用来控制对特定对象的访问。

2. 类锁：类锁是针对类的，而不是针对对象的。它可以通过使用 `static synchronized` 方法或使用 `synchronized` 块来实现。类锁用于控制对类的所有实例的访问。

3. 公平锁：公平锁是指多个线程在等待同一个锁时，必须按照请求锁的顺序来获取锁。这意味着，如果线程 T1 先于线程 T2 请求锁，那么线程 T1 将优先获得锁。Java 中的 `ReentrantLock` 类实现了公平锁。

4. 非公平锁：非公平锁是指多个线程在等待同一个锁时，并不按照请求锁的顺序来获取锁。这意味着，如果线程 T1 先于线程 T2 请求锁，那么线程 T1 可能不会优先获得锁。Java 中的 `ReentrantLock` 类默认实现了非公平锁。

5. 可重入锁：可

相关问题

说说java中常用的锁

Java 中常用的锁主要分为两大类：内置锁和自定义锁。

### 1. 内置锁

#### **synchronized关键字**
`synchronized`是最常见的锁机制之一，在 Java 中它主要用于线程同步，允许对共享资源访问的并发控制。它可以应用于方法级别（通过 `synchronized (object) {}`）或代码块级别（通过 `synchronized (lockObject) { ... }`）。当一个线程进入一个 synchronized 代码块时，其他试图在同一对象上调用 synchronized 的线程会被阻塞，直到当前线程完成对该代码块的访问。这种方法简单直观，易于理解，但也可能导致一些性能问题，特别是对于高并发情况下的大量锁竞争。

#### **ReentrantLock**
`ReentrantLock`是一个非公平锁，意味着当有多个线程等待获取锁时，会按照线程的等待顺序依次释放锁。其优点在于可以通过 `tryLock()` 来尝试立即获取锁而不阻塞，同时支持公平性和非公平性策略。这意味着在非公平模式下，如果有一个线程正在等待获取锁，则新到达的线程需要排队等待。这使得 ReentrantLock 更适合于需要精确控制锁等待队列的应用场景。

### 2. 自定义锁

**自定义锁（Custom Lock）**
有时，开发者需要基于特定的场景定制锁的行为。这种情况下，可以设计和实现自己的锁类，以满足特定的性能、互斥性和并发控制需求。例如，可以在某些应用中使用基于信号量的自定义锁来控制并发执行的数量，或者基于原子变量的自定义锁来实现轻量级的同步。

### 示例代码

以下是使用 `ReentrantLock` 的一个例子：

import java.util.concurrent.locks.ReentrantLock;

public class CustomCounter {

    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` 来保证线程安全地对共享计数器的操作。

---
相关问题:
1. 在哪些场景下选择使用 `synchronized` 或者 `ReentrantLock` 更合适？
2. 自定义锁的主要优势是什么？何时需要自定义锁？
3. 解释一下 Java 并发库中 `ReadWriteLock` 和 `Semaphore` 分别是如何使用的？

java锁种类得区别

Java有多种锁类型，它们的区别如下：

1. 内置锁(intrinsic lock)或监视器锁(monitor lock)：这是Java中最常用的锁类型。内置锁是Java中每个对象都有的一个内置的锁，可以用来保护对象的访问。内置锁可以通过`synchronized`关键字获取和释放。

2. 可重入锁(reentrant lock)：可重入锁是一种可以被单个线程多次获取的锁。当一个线程已经获取了可重入锁，它就可以再次获取该锁，而不会被阻塞。可重入锁是通过`java.util.concurrent.locks.ReentrantLock`类实现的。

3. 读写锁(read-write lock)：读写锁允许多个读线程同时访问共享资源，但是如果有一个写线程想要访问共享资源，则所有的读线程和其他的写线程都必须等待。读写锁是通过`java.util.concurrent.locks.ReadWriteLock`接口及其实现类实现的。

4. 公平锁(fair lock)和非公平锁(non-fair lock)：公平锁是指线程获取锁的顺序是按照线程加锁的顺序来分配的，而非公平锁则不保证锁的获取顺序。对于可重入锁和读写锁，都可以指