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

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