Java并发包中锁原理剖析

6.1LockSupport

跟wait()不同！

引入了一个许可证的概念。

void park()方法

检测此时的线程是否拥有许可证，有的话。就通过，没有的话就阻塞。

LockSupport.park()：在哪儿调用就是检查哪个线程

void unpark(Thread thread)方法

LockSupport.unpark(t)：给t线程发一个许可证。

LockSupport.parkNanos(long nanos)

如果有许可证，直接返回

如果没有许可证，那就等一会再返回

LockSupport.park(Object blocker)方法

讲blocker参数传入到阻塞线程中去

LockSupport.parkNanos(Object blocker, long nanos)

相对时间

LockSupport.parkUnitl(Object blocker, long deadline)

准确时间

大名鼎鼎的AQS

AbstractQueuedSynchronized：简称AQS，抽象同步队列；实现同步锁的基础组件。

并发包中的锁底层就是使用AQS实现的。

AQS是一个FIFO的双向队列，其内部通过节点head和tail记录队首和队尾元素，队列元素的类型是Node。

Node节点用来保存一条线程：

Shared：标记该线程是获取共享资源时被阻塞挂起后放入AQS队列的
EXCLUSIVE：标记线程是获取独占资源时被挂起后放入AQS队列的
CANCLELED：线程被取消
SIGNAL：线程需要被唤醒
CONDITION：线程条件队列里面等待
PROPAGATE：释放共享资源时需要通知其它节点
pre：前驱节点
next：后继节点

最终要的AQS中的state是实现不同锁的基础！

AQS中有内部类ConditionObject类：每个对象对应一个条件队列（单向链表队列）：其中放调用条件变量await方法后被阻塞的线程。

对于ReentrantLock来说：state指的是可重入锁的次数

对于ReetrantReadWriteLock来说：高十六位是：读的重入数；低十六位：写锁的重入数；

对于CountDownlatch来说：state用来表示计数器当前的值

根据state是否属于一个线程：操作state的方式分为独占式和共享式。

独占式

谁获得了锁，state从0---->1；假如重入获取，state+1；解锁：state-1；

没有获取到锁：放入AQS阻塞队列中

释放资源

boolean release（int args）

获取资源

void acquire(int arg)：不响应中断

获取锁，没有就讲线程保存到AQS的阻塞队列里头。

void acquireInterruptibly(int arg)：响应中断

共享式

例如信号量Semaphore：多个线程去请求资源时通过CAS方式竞争资源，当一个线程获取到了资源后，另外一个线程再次去获取时如果当前资源还能满足它的需要，则当前线程只需要使用CAS方式获取即可。

释放资源

boolean releaseShared（int args）

获取资源

void acquireShared(int arg)：不响应中断

void acquireInterruptiblyShared(int arg)：响应中断

----------------------------------------------------------------------------------------------------------------------------------------------------------------

获取锁：都是CAS
成功：执行

失败：LockSupport.park()假如到AQS队列里头等待

释放：释放成功，LockSupport.unpar()唤醒一个，CAS获取锁咯。

上述的tryxx的方法AQS需要实现的子类自己写

例如：ReentrantReadWriteLock

读锁重写tryAcquireShared时，首先查看写锁是否被其它线程持有，如果有则直接返回false，否则使用CAS递增state的高16位；

释放读锁时：重写tryRealeaseShared时，在内部需要使用CAS算法把当前state的高16位减1.

isHeldExclusively()：判断锁是被当前线程独占还是被共享。

-------------------------------------------------------------------------------------------------------------------------------------------------------------------

node节点入队操作

AQS---条件变量的支持

就是之前的哪个ConditionObject类

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionTest {

    public static void main(String[] args) {

        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                System.out.println("I am one");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("I am one signal");
                    lock.unlock();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                lock.lock();
                System.out.println("I am two");
                condition.signal();
                System.out.println("I am two");
                lock.unlock();
            }
        }).start();
    }

    /**
     * I am one
     * I am two
     * I am two
     * I am one signal
     */
}