也来说说Java中的锁--并发编程关键知识点
也来说说Java中的锁
一，什么是java中的锁
1，从java语法上来说，java中的锁，指的就是java给我们提供的Lock接口以及相关的实现类。
2，从架构上来说，锁是一种同步机制；
3，从功能上来说，锁是用来控制多个线程访问共享资源的方式，防止多个线程同时访问共享资源。
二，从JVM的角度来看锁
说起锁，就要说一下synchronized关键字。锁是JDK5开始才引入的一个功能，而synchronized
关键字在JDK5之前就已经存在了，并且在没有锁的日子里，java就靠synchronized关键字来实现锁
的功能的。锁与synchronized关键字也相似的功能，区别就在于锁是显示的，而synchronized关键
字是隐式的。
1，锁的内存语义
锁是一种同步机制，锁可以让临界区互斥的执行，在多线程环境下实现强同步，并且锁L在释放
时，释放锁L的A线程会通知获得锁L的B线程。这就是锁的内存语义。
2，锁的释放和获取的内存语义
第一点：锁的释放的内存语义是：当线程A释放锁时，Java内存模型会把本地内存中的共享变量
的值刷新到主内存中。
第二点：锁的获取的内存语义是：当线程A获取锁时，Java内存模型会把本地内存中的共享变量
的值置为无效，然后去主内存中读取新值。
在这里补充说明一下，锁的释放和volatile关键字的写操作具有相同的内存语义，锁的获取和
volatile关键字的读具有相同的内存语义。并且从实现上来说，Java中锁机制的实现，依赖于
volatile关键字。
读者请思考：锁与volatile的不同点？
3，锁的内存语义的实现
锁有很多种实现，这里我们仅仅以最常用的可重入锁ReentrantLock为例来说明，可重入锁
ReentrantLock的内存语义的实现是这样的：调用Lock方法获取锁，调用unlock方法释放锁。可重入
锁的实现依赖于AQS（AbstractQueueSynchronizer）同步器框架。而AQS实现的关键就是volatile关
键字，因此我们通常说，锁的内存语义的实现，依赖于volatile关键字。
三，从功能实现和使用的角度来看锁
Java支持多线程，也就是多个线程可以同时访问同一个变量或者对象，由于每个对象都拥有这个
变量的拷贝，所以在程序的执行过程中，某个线程看到的变量的值不一定是最新的，因此就产生了线
程同步的问题。之所以每个线程都拥有一份拷贝，是为了加快程序的运行速度，这是很多多核处理器
的共性。
1，锁的使用方法
锁的使用方法比较简单，通过下面一段代码，就可以熟悉锁是如何使用的。
下面我们来看一下Lock接口：
lock()：获取锁，调用该方法后，当前线程马上获得锁，当锁获得后，从该方法返回。
lockInterruptibly()：获取锁（支持中断获取锁）
tryLock()：获取锁（非阻塞的获取锁，调用该方法后，会立即返回）
tryLock(long time, TimeUnit unit)：获取锁（支持超时获取锁）
unlock()：释放锁
newCondition()：获取等待通知组件，该组件和当前的锁绑定，当前线程只有获得了锁，
才能调用该组件的wait方法，而调用后，当前线程将被释放锁。
源码中注释很详细，大家可以细细品味一番：
2，锁与synchronized关键字的比较
说到锁，就不得不提锁的始祖synchronized关键字，首先来看一下synchronized关键字的使用。
总结一下，锁与synchronized关键字都可以实现锁的功能，由于锁是诞生在
synchronized关键字之后，所以锁更具有先进性，它具有一些synchronized
关键字不具有的功能，主要有以下几个方面：
支持非阻塞的获取锁；
支持中断的获取锁；
支持超时获取锁；
四，AQS同步器框架（AbstractQueueSynchronizer）
锁的实现，依赖的就是AQS，Lock接口的实现基本上都是通过聚合了一个同步
器的子类来完成线程访问控制的。AQS又叫队列同步器，是用来构建锁或者其他同
步组件的基础框架。AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队
列来完成资源获取线程的排队工作。
AQS的主要使用方法是继承，子类通过继承同步器AQS，然后实现它的抽象方法
来管理同步状态。
队列同步器AQS是锁的实现的关键，在锁的实现中聚合队列同步器，利用队列同
步器实现锁的语义。可以这样理解二者之间的关系：锁是面向使用者的，同步器是面
向锁的实现类。
1，同步框架AQS的使用说明
首先自定义一个锁，独占锁，也就是说在同一时刻只有一个线程可以获得锁。
然后编写一个测试类，启动10个线程，竞争一个资源，每1.5秒打印一行信息
控制台输出信息（由于竞争关系，控制台输出是随机的，每次运行结果不同）：
五，可重入锁 java.util.concurrent.locks.ReentrantLock
1，什么是可重入锁
可重入锁，就是支持重新进入的锁，也就是支持同一个线程重复的获取同一个锁。可
重入锁与我们之前定义的独占锁，有什么区别呢，一个明显的区别就是，如果我们在一个
线程A获取锁之后，再次调用lock.lock()方法，此时，线程A会被阻塞，线程A自己把自己
阻塞了，如果这样修改一下，上面程序的运行结果就会变成这样：
2，可重入锁是如何实现的
可重入锁java.util.concurrent.locks.ReentrantLock中，有一个方法用来判断当前线程
是否是获取锁的线程，也就是说如果是一个已经获取锁的线程A，再次调用lock.lock()方法时，
可重入锁会将同步状态值加增加，然后返回true，表示获取锁成功。源代码如下：
这样处理以后，释放锁时，相应的也要改变处理逻辑：
3，可重入锁的公平与非公平竞争实现
可重入锁支持以公平的方式，还是非公平的方式获取锁。设置很简单，通过下面的
代码，在创建锁对象时进行设置：
源码如下：
这2种获取锁的方式有什么区别呢？区别就在于，以公平方式获取锁时，会判断当前线程是
不是第一个请求获取该锁的线程。如果是第一个请求获取该锁的线程，则获取锁成功；否则
获取锁失败。
六，读写锁 java.util.concurrent.locks.ReentrantReadWriteLock;
1，什么是读写锁
读写锁这样一种锁，它允许多个线程在同一时刻同时访问某个资源。读写锁维护
了一对锁，一个读锁和一个写锁，其实原理就是读写分离，因为在以读为主的场景下，
大部分时间都是读取，我们都知道，多个读线程同时访问，始终能保持同步状态。所以
此时不加锁可以有效的提高程序的执行速度。
2，读写锁的实现原理
读写锁的原理，其实就是维护了2个锁，一个读锁和一个写锁。在读操作时获取读
锁，写操作时获取写锁。当写锁被获取到时，后面的读写请求都被阻塞，写锁释放后，
后面的读写操作继续执行。
读锁和写锁，都是ReentrantReadWriteLock的内部类，这2个锁，都是实现了Lock接口的
实现类。
七，Condition接口
1，Condition的作用
Condition接口提供了类似Object的监视器方法，与锁配合可以实现等待/通知模式。我们
都知道，任意一个Java对象，都具有下面这几个方法：
wait(); // 等待
wait(long timeout); // 超时等待
notify(); // 唤醒
notifyAll(); // 唤醒所有
这些方法我们很少用到，但是Java都提供给我们了。这些方法有什么作用呢？其实这些方法都
是Object对象的监视器，与synchronized关键字配合使用，可以实现等待/通知模式。
Condition接口也提供了类似的一些方法，源码如下：
Condition接口与Lock配合，可以实现等待/通知模式。看到这里，大家可能有些疑惑了，
Object监视器 + synchronized关键字
Condition监视器 + Lock
这不就是等待/通知模式的升级版吗！
2，Condition的使用
测试类：ConditionLearningTest.java
好了，写到这里，关于锁的讲解暂时告一段落，笔者水平有限，难免有不妥之处，请见谅。
一，什么是java中的锁
1，从java语法上来说，java中的锁，指的就是java给我们提供的Lock接口以及相关的实现类。
public interface Lock ，通常我们这样来创建锁对象：
Lock lock = new ReentrantLock(); 2，从架构上来说，锁是一种同步机制；
3，从功能上来说，锁是用来控制多个线程访问共享资源的方式，防止多个线程同时访问共享资源。
二，从JVM的角度来看锁
说起锁，就要说一下synchronized关键字。锁是JDK5开始才引入的一个功能，而synchronized
关键字在JDK5之前就已经存在了，并且在没有锁的日子里，java就靠synchronized关键字来实现锁
的功能的。锁与synchronized关键字也相似的功能，区别就在于锁是显示的，而synchronized关键
字是隐式的。
1，锁的内存语义
锁是一种同步机制，锁可以让临界区互斥的执行，在多线程环境下实现强同步，并且锁L在释放
时，释放锁L的A线程会通知获得锁L的B线程。这就是锁的内存语义。
2，锁的释放和获取的内存语义
第一点：锁的释放的内存语义是：当线程A释放锁时，Java内存模型会把本地内存中的共享变量
的值刷新到主内存中。
第二点：锁的获取的内存语义是：当线程A获取锁时，Java内存模型会把本地内存中的共享变量
的值置为无效，然后去主内存中读取新值。
在这里补充说明一下，锁的释放和volatile关键字的写操作具有相同的内存语义，锁的获取和
volatile关键字的读具有相同的内存语义。并且从实现上来说，Java中锁机制的实现，依赖于
volatile关键字。
读者请思考：锁与volatile的不同点？
3，锁的内存语义的实现
锁有很多种实现，这里我们仅仅以最常用的可重入锁ReentrantLock为例来说明，可重入锁
ReentrantLock的内存语义的实现是这样的：调用Lock方法获取锁，调用unlock方法释放锁。可重入
锁的实现依赖于AQS（AbstractQueueSynchronizer）同步器框架。而AQS实现的关键就是volatile关
键字，因此我们通常说，锁的内存语义的实现，依赖于volatile关键字。
三，从功能实现和使用的角度来看锁
Java支持多线程，也就是多个线程可以同时访问同一个变量或者对象，由于每个对象都拥有这个
变量的拷贝，所以在程序的执行过程中，某个线程看到的变量的值不一定是最新的，因此就产生了线
程同步的问题。之所以每个线程都拥有一份拷贝，是为了加快程序的运行速度，这是很多多核处理器
的共性。
1，锁的使用方法
锁的使用方法比较简单，通过下面一段代码，就可以熟悉锁是如何使用的。
package com.spider.java;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
*
* @author yangcq
* @desctiption Java中的锁
*
*/
public class LockLearning {
// 定义一个全局变量，账户余额
private static int account_balance = 1000000000;
public static void main(String[] args) {
// 创建可重入锁对象lock
Lock lock = new ReentrantLock();
// 在执行一段代码之前获取锁
lock.lock();
// 执行代码，修改余额的值，这里可以是我们项目中任何一个需要加锁的操作
updateAccountBalance(account_balance);
// 在执行一段代码之后释放锁
lock.unlock();
}
private static int updateAccountBalance(Integer account_balance){
return account_balance - 1000;
}
}
下面我们来看一下Lock接口：
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}
lock()：获取锁，调用该方法后，当前线程马上获得锁，当锁获得后，从该方法返回。
lockInterruptibly()：获取锁（支持中断获取锁）
tryLock()：获取锁（非阻塞的获取锁，调用该方法后，会立即返回）
tryLock(long time, TimeUnit unit)：获取锁（支持超时获取锁）
unlock()：释放锁
newCondition()：获取等待通知组件，该组件和当前的锁绑定，当前线程只有获得了锁，
才能调用该组件的wait方法，而调用后，当前线程将被释放锁。
源码中注释很详细，大家可以细细品味一番：
/**
* Returns a new {@link Condition} instance that is bound to this
* {@code Lock} instance.
*
* Before waiting on the condition the lock must be held by the
* current thread.
* A call to {@link Condition#await()} will atomically release the lock
* before waiting and re-acquire the lock before the wait returns.
*
*
Implementation Considerations
*
*
The exact operation of the {@link Condition} instance depends on
* the {@code Lock} implementation and must be documented by that
* implementation.
*
* @return A new {@link Condition} instance for this {@code Lock} instance
* @throws UnsupportedOperationException if this {@code Lock}
* implementation does not support conditions
*/
2，锁与synchronized关键字的比较
说到锁，就不得不提锁的始祖synchronized关键字，首先来看一下synchronized关键字的使用。
package com.spider.java;
import java.util.logging.Logger;
/**
*
* @author yangcq
* @description synchronized关键字的使用方法
*
*/
public class SynchronizedLearning {
static Logger logger = Logger.getAnonymousLogger();
public static void main(String[] args) {
/**
* synchronized关键字实现同步有2种方式，同步方法和同步块
*/
// 同步块
synchronized(SynchronizedLearning.class){
logger.info("我是同步块...");
}
synchronizedMethod();
}
// 同步方法
public static synchronized void synchronizedMethod(){
logger.info("我是同步方法...");
}
}总结一下，锁与synchronized关键字都可以实现锁的功能，由于锁是诞生在
synchronized关键字之后，所以锁更具有先进性，它具有一些synchronized
关键字不具有的功能，主要有以下几个方面：
支持非阻塞的获取锁；
支持中断的获取锁；
支持超时获取锁；
四，AQS同步器框架（AbstractQueueSynchronizer）
锁的实现，依赖的就是AQS，Lock接口的实现基本上都是通过聚合了一个同步
器的子类来完成线程访问控制的。AQS又叫队列同步器，是用来构建锁或者其他同
步组件的基础框架。AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队
列来完成资源获取线程的排队工作。
AQS的主要使用方法是继承，子类通过继承同步器AQS，然后实现它的抽象方法
来管理同步状态。
队列同步器AQS是锁的实现的关键，在锁的实现中聚合队列同步器，利用队列同
步器实现锁的语义。可以这样理解二者之间的关系：锁是面向使用者的，同步器是面
向锁的实现类。
1，同步框架AQS的使用说明
首先自定义一个锁，独占锁，也就是说在同一时刻只有一个线程可以获得锁。
package com.spider.java;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
*
* @author yangcq
* @description 自定义锁 - 独占锁UserDefineLock，也就是在同一时刻，只有一个线程可以获得锁
*
*/
public class UserDefineLock implements Lock {
// 使用队列同步器AQS以后，我们只需要将锁的操作代理到自定义的同步器上就可以了
private final SynchronizerDefine synchronizerDefine = new SynchronizerDefine();
@Override
public void lock() {
synchronizerDefine.acquire(1);
}
@Override
public void lockInterruptibly() throws InterruptedException {
synchronizerDefine.acquireInterruptibly(1);
}
@Override
public boolean tryLock() {
return synchronizerDefine.tryAcquire(1);
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return synchronizerDefine.tryAcquireNanos(1, unit.toNanos(time));
}
@Override
public void unlock() {
synchronizerDefine.release(1);
}
@Override
public Condition newCondition() {
return synchronizerDefine.newCondition();
}
public boolean hasQueueThreads(){
return synchronizerDefine.hasQueuedThreads();
}
public boolean isLocked(){
return synchronizerDefine.isHeldExclusively();
}
// 静态内部类，自定义同步器
private static class SynchronizerDefine extends AbstractQueuedSynchronizer{
/**
*
*/
private static final long serialVersionUID = -5572420543429760541L;
// 判断当前锁是否处于占用状态
protected boolean isHeldExclusively(){
return getState() == 1;
}
// 当状态为0时，获取锁
public boolean tryAcquire(int acquires){
if(compareAndSetState(0,1)){
// 官方注释：Sets the thread that currently owns exclusive access.
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// 释放锁之后，将状态设置为0
protected boolean tryRelease(int releases){
if(getState() == 0){
throw new IllegalMonitorStateException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// 返回一个Condition，每个Condition都包含一个condition实例
Condition newCondition(){
return new ConditionObject();
}
}
}然后编写一个测试类，启动10个线程，竞争一个资源，每1.5秒打印一行信息
package com.spider.java;
import java.util.concurrent.locks.Lock;
import java.util.logging.Logger;
/**
*
* @author yangcq
* @description 队列同步器AbstractQueuedSynchronizer
* @description public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
*
*/
public class AbstarctQueueSynchronizerLearning {
// 打印logger日志
static Logger logger = Logger.getAnonymousLogger();
// 主方法
public static void main(String[] args){
test();
}
public static void test(){
final Lock lock = new UserDefineLock();
class ProductThread extends Thread{
public void run(){
while(true){
lock.lock();
try{
sleep(1500);
logger.info(Thread.currentThread().getName());
sleep(1500);
}
catch(Exception e){
lock.unlock();
}
finally{
lock.unlock();
}
}
}
}
// 启动5个线程
for(int i=0;i<10;i++){
ProductThread productThread = new ProductThread();
productThread.setDaemon(true);
productThread.start();
}
// 每隔1.5秒 打印 -----------
for(int i=0;i<10;i++){
try {
ProductThread.sleep(1500);
logger.info("-----------");
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
控制台输出信息（由于竞争关系，控制台输出是随机的，每次运行结果不同）：
2016-7-31 1:44:04 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:04 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-1
2016-7-31 1:44:06 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:07 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-1
2016-7-31 1:44:07 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:09 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:10 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:10 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-1
2016-7-31 1:44:12 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:13 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-3
2016-7-31 1:44:13 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:15 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:16 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:16 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-3
2016-7-31 1:44:18 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------五，可重入锁 java.util.concurrent.locks.ReentrantLock
1，什么是可重入锁
可重入锁，就是支持重新进入的锁，也就是支持同一个线程重复的获取同一个锁。可
重入锁与我们之前定义的独占锁，有什么区别呢，一个明显的区别就是，如果我们在一个
线程A获取锁之后，再次调用lock.lock()方法，此时，线程A会被阻塞，线程A自己把自己
阻塞了，如果这样修改一下，上面程序的运行结果就会变成这样：
2016-7-31 1:58:50 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:51 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:53 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:54 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:56 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:57 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:59 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:59:00 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:59:02 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:59:03 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------2，可重入锁是如何实现的
可重入锁java.util.concurrent.locks.ReentrantLock中，有一个方法用来判断当前线程
是否是获取锁的线程，也就是说如果是一个已经获取锁的线程A，再次调用lock.lock()方法时，
可重入锁会将同步状态值加增加，然后返回true，表示获取锁成功。源代码如下：
/**
* Performs non-fair tryLock. tryAcquire is
* implemented in subclasses, but both need nonfair
* try for trylock method.
*/
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}这样处理以后，释放锁时，相应的也要改变处理逻辑：
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}3，可重入锁的公平与非公平竞争实现
可重入锁支持以公平的方式，还是非公平的方式获取锁。设置很简单，通过下面的
代码，在创建锁对象时进行设置：
Lock lock = new ReentrantLock(true); // 以公平的方式获取锁
Lock lock = new ReentrantLock(false); // 以非公平的方式获取锁源码如下：
/**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = (fair)? new FairSync() : new NonfairSync();
}这2种获取锁的方式有什么区别呢？区别就在于，以公平方式获取锁时，会判断当前线程是
不是第一个请求获取该锁的线程。如果是第一个请求获取该锁的线程，则获取锁成功；否则
获取锁失败。
/**
* Sync object for fair locks 以公平的方式获取锁
*/
final static class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 区别就在于这里，以公平方式获取锁时，会判断当前线程是不是
// 第一个请求获取该锁的线程。
if (isFirst(current) && compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
/**
* Sync object for non-fair locks 以非公平的方式获取锁
*/
final static class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
// 非公平方式的方法实现nonfairTryAcquire
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}六，读写锁 java.util.concurrent.locks.ReentrantReadWriteLock;
1，什么是读写锁
读写锁这样一种锁，它允许多个线程在同一时刻同时访问某个资源。读写锁维护
了一对锁，一个读锁和一个写锁，其实原理就是读写分离，因为在以读为主的场景下，
大部分时间都是读取，我们都知道，多个读线程同时访问，始终能保持同步状态。所以
此时不加锁可以有效的提高程序的执行速度。
2，读写锁的实现原理
读写锁的原理，其实就是维护了2个锁，一个读锁和一个写锁。在读操作时获取读
锁，写操作时获取写锁。当写锁被获取到时，后面的读写请求都被阻塞，写锁释放后，
后面的读写操作继续执行。
public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable
/** Inner class providing readlock 读锁（内部类）*/
private final ReentrantReadWriteLock.ReadLock readerLock;
/** Inner class providing writelock 写锁（内部类）*/
private final ReentrantReadWriteLock.WriteLock writerLock;
/** Performs all synchronization mechanics 队列同步器AQS实现类*/
private final Sync sync;读锁和写锁，都是ReentrantReadWriteLock的内部类，这2个锁，都是实现了Lock接口的
实现类。
public static class ReadLock implements Lock, java.io.Serializable // 读锁
public static class WriteLock implements Lock, java.io.Serializable // 写锁七，Condition接口
1，Condition的作用
Condition接口提供了类似Object的监视器方法，与锁配合可以实现等待/通知模式。我们
都知道，任意一个Java对象，都具有下面这几个方法：
wait(); // 等待
wait(long timeout); // 超时等待
notify(); // 唤醒
notifyAll(); // 唤醒所有
这些方法我们很少用到，但是Java都提供给我们了。这些方法有什么作用呢？其实这些方法都
是Object对象的监视器，与synchronized关键字配合使用，可以实现等待/通知模式。
Condition接口也提供了类似的一些方法，源码如下：
public interface Condition {
void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal();
void signalAll();
}Condition接口与Lock配合，可以实现等待/通知模式。看到这里，大家可能有些疑惑了，
Object监视器 + synchronized关键字
Condition监视器 + Lock
这不就是等待/通知模式的升级版吗！
2，Condition的使用
package com.spider.java;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Logger;
/**
*
* @author yangcq
* @description Condition接口 + Lock 实现等待/通知模式
* @description 测试类 ConditionLearningTest
*
*/
public class ConditionLearning {
static Logger logger = Logger.getAnonymousLogger(); // 日志
Lock lock = new ReentrantLock();
Condition condition_get = lock.newCondition();
// 定义一个Map
Map map = new HashMap();
// 取值 -- 如果值为空，则等待...
public void conditionWait() throws InterruptedException{
map.put("yangcq", "");
lock.lock();
try{
while("".equals(map.get("yangcq"))){
logger.info("key 'yangcq' 为空，不能取值...");
condition_get.await();
}
logger.info("key 'yangcq' 的值为：" + map.get("yangcq"));
}
finally{
lock.unlock();
}
}
// 赋值 -- 赋值以后，有值了，唤醒
public void conditionSignal() throws InterruptedException{
map.put("yangcq", "1988");
lock.lock();
try{
if("".equals(map.get("yangcq"))){
logger.info("key 'yangcq' 为空，不能让其他方法从这里取值...");
}
else{
logger.info("key 'yangcq' 有值，可以唤醒取值的方法");
// 唤醒取值线程（消费者线程）
condition_get.signal();
}
}
finally{
lock.unlock();
}
}
} 测试类：ConditionLearningTest.java
package com.spider.java;
/**
*
* @author yangcq
* @description Condition接口 + Lock 实现等待/通知模式测试
*
*/
public class ConditionLearningTest {
// 创建ConditionLearning对象
static ConditionLearning conditionLearning = new ConditionLearning();
public static void main(String[] args) {
getValue(); // 初始值为空，消费者线程等待...
putValue(); // 生产者赋值以后，有值了，通知消费者线程，然后消费者线程唤醒
}
@SuppressWarnings("static-access")
public static void getValue(){
// 消费者线程
class ConsumerThread extends Thread{
public void run(){
try {
conditionLearning.conditionWait();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
ConsumerThread ConsumerThread = new ConsumerThread();
ConsumerThread.start();
try {
ConsumerThread.sleep(2000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void putValue(){
// 生产者线程
class ProductThread extends Thread{
public void run(){
try {
conditionLearning.conditionSignal();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
ProductThread ProductThread = new ProductThread();
ProductThread.start();
}
}好了，写到这里，关于锁的讲解暂时告一段落，笔者水平有限，难免有不妥之处，请见谅。