小结java自带的跟锁相关的一些类

时间：2023-02-01 16:19:20

java.util.concurrent包下的一些跟锁相关的类列表

 类  简介
locks.Lock接口

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

所有已知实现类：ReentrantLock, ReentrantReadWriteLock.ReadLock, ReentrantReadWriteLock.WriteLock

方法包括：

void lock()
          获取锁。
void unlock()
          释放锁。
locks.Condition newCondition()
          返回绑定到此 Lock 实例的新 Condition
实例。
boolean tryLock()
          仅在调用时锁为空闲状态才获取该锁。
boolean tryLock(long time, TimeUnit unit)
          如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁。
void lockInterruptibly()
          如果当前线程未被中断，则获取锁。
locks.ReentrantLock类 
public class ReentrantLock extends Object implements Lock, Serializable

一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

可以实现公平锁，默认为非公平锁。

构造函数：

ReentrantLock()
          创建一个 ReentrantLock 的实例（非公平锁）。
ReentrantLock(boolean fair)
          创建一个具有给定公平策略的 ReentrantLock。

常用方法：

Lock接口上定义的那些方法 + 下面表中的查询方法

int getHoldCount()
          查询当前线程保持此锁的次数。
protected  Thread getOwner()
          返回目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回 null。
protected Collection<Thread> getQueuedThreads()
          返回一个 collection，它包含可能正等待获取此锁的线程。
int getQueueLength()
          返回正等待获取此锁的线程估计数。
protected  Collection<Thread> getWaitingThreads(Condition condition)
          返回一个 collection，它包含可能正在等待与此锁相关给定条件的那些线程。
int getWaitQueueLength(Condition condition)
          返回等待与此锁相关的给定条件的线程估计数。
boolean hasQueuedThread(Thread thread)
          查询给定线程是否正在等待获取此锁。
boolean hasQueuedThreads()
          查询是否有线程正在等待获取此锁。
boolean hasWaiters(Condition condition)
          查询是否有些线程正在等待与此锁有关的给定条件。
boolean isFair()
          如果此锁的公平设置为 true，则返回 true。
boolean isHeldByCurrentThread()
          查询当前线程是否保持此锁。
String toString()
    返回标识此锁及其锁定状态的字符串。
locks.ReadWriteLock接口

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。

所有已知实现类：locks.ReentrantReadWriteLock

Lock readLock()
          返回用于读取操作的锁。
Lock writeLock()
          返回用于写入操作的锁。

locks.

ReentrantReadWriteLock

类

 
public class ReentrantReadWriteLock extends Object implements ReadWriteLock, Serializable

该类有如下几个特点：

1、默认为非公平锁模式，可以调用有参的构造函数构建公平锁。

2、可重入：

此锁允许 reader 和 writer 按照 ReentrantLock 的样式重新获取读取锁或写入锁。在写入线程保持的所有写入锁都已经释放后，才允许重入 reader 使用它们。

此外，writer 可以获取读取锁，但反过来则不成立。在其他应用程序中，当在调用或回调那些在读取锁状态下执行读取操作的方法期间保持写入锁时，重入很有用。如果 reader 试图获取写入锁，那么将永远不会获得成功。

3、锁降级：允许从写入锁降级为读取锁，其实现方式是：先获取写入锁，然后获取读取锁，最后释放写入锁。但是，从读取锁升级到写入锁是不可能的。

示例：

class CachedData {

   Object data;

   volatile boolean cacheValid;

   ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

   void processCachedData() {

     rwl.readLock().lock();

     if (!cacheValid) {

        // Must release read lock before acquiring write lock

        rwl.readLock().unlock();

        rwl.writeLock().lock();

        // Recheck state because another thread might have acquired

        //   write lock and changed state before we did.

        if (!cacheValid) {

          data = ...

          cacheValid = true;

        }

        // Downgrade by acquiring read lock before releasing write lock

        rwl.readLock().lock();

        rwl.writeLock().unlock(); // Unlock write, still hold read

     }

     use(data);

     rwl.readLock().unlock();

   }

 }

4、锁获取可中断：读取锁和写入锁都支持锁获取期间的中断。

5、写锁Condition支持，但读锁不支持Condition。

注意事项：此锁最多支持 65535 个递归写入锁和 65535 个读取锁。试图超出这些限制将导致锁方法抛出 Error。

构造函数：

ReentrantReadWriteLock()
          使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock。
ReentrantReadWriteLock(boolean fair)
          使用给定的公平策略创建一个新的 ReentrantReadWriteLock。

嵌套类：

static class ReentrantReadWriteLock.ReadLock
          readLock()
方法返回的锁。
static class ReentrantReadWriteLock.WriteLock
          writeLock()
方法返回的锁。

主要的方法有：

protected  Thread getOwner()
          返回当前拥有写入锁的线程，如果没有这样的线程，则返回 null。
protected  Collection<Thread> getQueuedReaderThreads()

          返回一个 collection，它包含可能正在等待获取读取锁的线程。
protected  Collection<Thread> getQueuedThreads()

          返回一个 collection，它包含可能正在等待获取读取或写入锁的线程。
protected  Collection<Thread> getQueuedWriterThreads()

          返回一个 collection，它包含可能正在等待获取写入锁的线程。
 int getQueueLength()

          返回等待获取读取或写入锁的线程估计数目。
 int getReadHoldCount()

          查询当前线程在此锁上保持的重入读取锁数量。
 int getReadLockCount()

          查询为此锁保持的读取锁数量。
protected  Collection<Thread> getWaitingThreads(Condition condition)

          返回一个 collection，它包含可能正在等待与写入锁相关的给定条件的那些线程。
 int getWaitQueueLength(Condition condition)

          返回正等待与写入锁相关的给定条件的线程估计数目。
 int getWriteHoldCount()

          查询当前线程在此锁上保持的重入写入锁数量。
 boolean hasQueuedThread(Thread thread)

          查询是否给定线程正在等待获取读取或写入锁。
 boolean hasQueuedThreads()

          查询是否所有的线程正在等待获取读取或写入锁。
 boolean hasWaiters(Condition condition)

          查询是否有些线程正在等待与写入锁有关的给定条件。
 boolean isFair()

          如果此锁将公平性设置为 ture，则返回 true。
 boolean isWriteLocked()

          查询是否某个线程保持了写入锁。
 boolean isWriteLockedByCurrentThread()

          查询当前线程是否保持了写入锁。
 ReentrantReadWriteLock.ReadLock readLock()

          返回用于读取操作的锁。
 String toString()

          返回标识此锁及其锁状态的字符串。
 ReentrantReadWriteLock.WriteLock writeLock()

          返回用于写入操作的锁。
 CountDownLatch类

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。该类为一次性的锁，不可重用。

构造函数：CountDownLatch(int count)

方法包括：

void await()
          使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。
boolean await(long timeout, TimeUnit unit)
          使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。
void countDown()
          递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
long getCount()
          返回当前计数。
String toString()
          返回标识此锁存器及其状态的字符串。
 CyclicBarrier类

一个同步辅助类，它允许一组线程互相等待（调用await），当等待的线程数达到构造函数中int parties(屏障)的数量时才线程组里的线程才能继续往下执行/退出，同时它有一个带Runnable入参的构造函数允许在线程组突破这个屏障后（但在释放所有线程之前）执行相关的Runnable的代码（也就是最后一个达成突破屏障的那个线程达到后）。该类可重用。

通俗点讲：在hadoop等map/reduce分布式计算框架中里有用到这种思想，将一个任务拆成多个子任务，然后最后一子任务完成后整个任务才能继续往下执行(汇总各个子任务的结果)。

构造函数：

CyclicBarrier(int parties)
          创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在启动
barrier 时执行预定义的操作。
CyclicBarrier(int parties,
Runnable barrierAction)

          创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动
barrier 时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行。

方法列表：

int await()
          在所有参与者都已经在此
barrier 上调用 await 方法之前，将一直等待。
 int await(long timeout,
TimeUnit unit)

          在所有参与者都已经在此屏障上调用
await 方法之前将一直等待,或者超出了指定的等待时间。
 int getNumberWaiting()

          返回当前在屏障处等待的参与者数目。
 int getParties()

          返回要求启动此 barrier 的参与者数目。
 boolean isBroken()

          查询此屏障是否处于损坏状态。
 void reset()

          将屏障重置为其初始状态。
 Semaphore类

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。

通俗的讲就是：一个令牌池，通过acquire()方法获取一个令牌，如果没获取到就等待，获取到了就继续执行，执行完毕通常需要调用release()方法归还令牌，当归还的时候回唤醒正在等待获取令牌的线程来争取这个令牌。

该类默认为非公平锁，但有公平锁的构造函数可选。

构造函数：

Semaphore(int permits)
          创建具有给定的许可数和非公平的公平设置的 Semaphore。
Semaphore(int permits,
boolean fair)
          创建具有给定的许可数和给定的公平设置的 Semaphore。

方法列表：

void acquire()
          从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。
 void acquire(int permits)

          从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞，或者线程已被中断。
 void acquireUninterruptibly()

          从此信号量中获取许可，在有可用的许可前将其阻塞。
 void acquireUninterruptibly(int permits)

          从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞。
 int availablePermits()

          返回此信号量中当前可用的许可数。
 int drainPermits()

          获取并返回立即可用的所有许可。
protected  Collection<Thread> getQueuedThreads()

          返回一个 collection，包含可能等待获取的线程。
 int getQueueLength()

          返回正在等待获取的线程的估计数目。
 boolean hasQueuedThreads()

          查询是否有线程正在等待获取。
 boolean isFair()

          如果此信号量的公平设置为 true，则返回 true。
protected
 void		 reducePermits(int reduction)

          根据指定的缩减量减小可用许可的数目。
 void release()

          释放一个许可，将其返回给信号量。
 void release(int permits)

          释放给定数目的许可，将其返回到信号量。
 String toString()

          返回标识此信号量的字符串，以及信号量的状态。
 boolean tryAcquire()

          仅在调用时此信号量存在一个可用许可，才从信号量获取许可。
 boolean tryAcquire(int permits)

          仅在调用时此信号量中有给定数目的许可时，才从此信号量中获取这些许可。
 boolean tryAcquire(int permits,
long timeout, TimeUnit unit)

          如果在给定的等待时间内此信号量有可用的所有许可，并且当前线程未被中断，则从此信号量获取给定数目的许可。
 boolean tryAcquire(long timeout,
TimeUnit unit)

          如果在给定的等待时间内，此信号量有可用的许可并且当前线程未被中断，则从此信号量获取一个许可。

相关文章