Concurrent-Lock

---

多线程之Concurrent

一、 Lock

Lock接口定义了锁的几个基本方法：

1. lock()
2. unlock()
3. trylock()
4. new Condition

Lock lock;
lock.lock()
    try{
        //TODO
    }
finallly{
    lock.unlock();
}

二、 AbstractQueuedSynchronizer

​ 并发工具包的作者（Doug Lea)希望它成为实现同步需求的基础。抽象类AbstractQueuedSynchronizer是用来构建锁和其他同步框架的基础。

​ 使用一个int成员变量的state来表示同步状态的获取；通过一个FIFO队列来完成对state通过状态获取线程的排队。

重写同步器锁获取和释放的方法

1. 独占式

   protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

1. 共享式

protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }
protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }
protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }

1. 同步器通过state来控制同步。使用同步器已经实现好三个方法来达到对同步的控制。

protected final int getState() {return state;}
protected final void setState(int newState) {state = newState;}
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);}

1. 通过继承同步器来实现Lock接口的锁的获取和释放。

   /**
    * @author liuwang
    * @date 2018/6/6
    */
   public class DemoLock implements Lock {
       private static class Sync extends AbstractQueuedSynchronizer{
           protected Sync() {
               super();
           }
   
           @Override
           protected boolean tryAcquire(int arg) {
               //TODO
               return super.tryAcquire(arg);
           }
   
           @Override
           protected boolean tryRelease(int arg) {
               //TODO
               return super.tryRelease(arg);
           }
   
           @Override
           protected int tryAcquireShared(int arg) {
               //TODO
               return super.tryAcquireShared(arg);
           }
   
           @Override
           protected boolean tryReleaseShared(int arg) {
               //TODO
               return super.tryReleaseShared(arg);
           }
   
           @Override
           protected boolean isHeldExclusively() {
               //TODO
               return super.isHeldExclusively();
           }
       }
       private Sync sync =new Sync();
       @Override
       public void lock() {
           sync.acquire(1);
       }
   
       @Override
       public void lockInterruptibly() throws InterruptedException {
           sync.acquireInterruptibly(1);
       }
   
       @Override
       public boolean tryLock() {
           return false;
       }
   
       @Override
       public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
           return sync.tryAcquire(1);
       }
   
       @Override
       public void unlock() {
           sync.release(1);
       }
   
       @Override
       public Condition newCondition() {
           return null;
       }
   }

三、ReentrantLock

可重入锁

四、WriteReadLock

读写锁

五、LockSupport

提供了直接对线程进行阻塞和唤醒的功能

六、Condition

使关联的锁等待，唤醒。

赏

谢谢你请我吃糖果

支付宝

微信