001 AQS核心-ReentrantLock使用与底层代码深度分析

        谈到并发，不得不谈ReentrantLock；而谈到ReentrantLock，不得不谈AbstractQueuedSynchronizer （AQS） ；类如其名，抽象的队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，比如我们之前的课程上讲到的： ReentrantLock/Semaphore/CountDownLatch；

        它维护了一个volatile int state（代表共享资源）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。这里volatile是核心关键词，具体volatile的语义，state的访问方式有三种:

•getState()

•setState()

•compareAndSetState()

        AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share （共享，多个线程可同时执行,例如Semaphore/CountDownLatch）不同的自定义同步器争用共享资源的方式也不同。

        自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：

•isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。

•tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。

•tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。

•tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。

•tryReleaseShared(int)：共享方式。尝试释放资源，成功则返回true，失败则返回false

        以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败（因为state是通过volatile关键字修饰，其被修改所以线程都会获悉），直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。

【重入锁，在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放锁定，并且必须使用finally进行释放，不然会造成锁永远无法释放，其他线程永远进不来的结果。】

public class UseReentrantLock {
    //定义ReentrantLock为成员变量
    private ReentrantLock reentrantLock = new ReentrantLock();
    
    //创建加锁的方法
    public void method() {
        /* 模仿源码逻辑
        CopyOnWriteArrayList<String> copy = new CopyOnWriteArrayList<>();
        copy.add("");
        //add()方法的源码写法
         public boolean add(E e) {
            final ReentrantLock lock = this.lock;
            lock.lock();  //入口处先上锁
            try {     //在try代码块中完成业务
                Object[] elements = getArray();
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len + 1);
                newElements[len] = e;
                setArray(newElements);
                return true;
            } //如有异常可以加入catch块，并且可以做异常后处理
            finally {   //通过finally释放锁
                lock.unlock();
            }
        }*/
        reentrantLock.lock();
        try {
            System.out.println("当前线程："+Thread.currentThread().getName()+"进入...");
            Thread.sleep(2000);//模拟线程具体操作和运行时间
            System.out.println("当前线程："+Thread.currentThread().getName()+"退出...");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            reentrantLock.unlock();
        }
    }
    
    public static void main(String[] args) {
        
        UseReentrantLock useLock = new UseReentrantLock();
        //useLock.method();//此时直接运行就会有main进入、main退出
        
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                useLock.method();
            }
            
        },"t1");
        
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                useLock.method();
            }
            
        },"t2");
        
        t1.start();
        t2.start();
    }

}

输出结果：体系其独占的特性

当前线程：t1进入...
当前线程：t1退出...
当前线程：t2进入...
当前线程：t2退出...

【阅读ReentrantLock源码来完成理解，并描述实现逻辑】

公平锁和非公平锁：

•Lock lock = new ReentrantLock(boolean isFair);

•lock用法：

•tryLock():尝试获得锁，获得结果用true/false返回。

•tryLock():在给定的时间内尝试获得锁，获得结果用true/false返回。

•isFair()：是否是公平锁。

•isLocked():是否锁定。

•getHoldCount(): 查询当前线程保持此锁的个数，也就是调用lock()次数。

•lockInterruptibly():优先响应中断的锁。

•getQueueLength():返回正在等待获取此锁定的线程数。

•getWaitQueueLength():返回等待与锁定相关的给定条件Condition的线程数。

•hasQueuedThread(Thread thread): 查询指定的线程是否正在等待此锁。

•hasQueuedThreads():查询是否有线程正在等待此锁。

•hasWaiters():查询是否有线程正在等待与此锁定有关的condition条件。