public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

即该线程阻塞时被中断，抛中断异常后线程退出，不会执行后面语句。
在interrupt过后，lock方法是不会中断的，响应中断

根据Lock接口的源码注释，Lock接口的实现，具备和同步关键字同样的内存语义。代码在运行时并且不能指令重排，不会被缓存

{@code Lock}实现提供了更广泛的锁定 使用{@code synchronized}方法可以获得的操作和声明。它们允许更灵活的结构，可能有完全不同的属性，并且可能支持多个关联的{@link Condition}对象。

ReentrantLock

ReentrantLock是lock接口的最经典实现，是一个可重入锁、悲观锁、独享锁、自旋锁；

默认是非公平锁

   public ReentrantLock() {
        sync = new NonfairSync();
    }

可以在初始化时设置为公平锁

  public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

重字面意思说reentrantlock是可重入的锁，可重入的概念在于下面的 代码执行过后

    static Lock lc = new ReentrantLock();
    static volatile int i = 0;
    public static void add() throws InterruptedException {
        lc.lock();
        i++;
        System.out.println("here im ..");
        Thread.sleep(1000L);
        add();

        lc.unlock();
    }

    public static void main(String args[]) throws InterruptedException {
        add();
    }

得到结果会一直打印值。
相同的线程，不互斥，会再次获取到锁，执行锁内代码。

reentrantlock怎么实现可重入锁的。

首先实现一个简单的不重入锁

public class MyLock implements Lock {

    //当前锁拥有者，若onwer为null，说明没有线程占用锁
    private Thread owner = null;
    //锁占用是，线程被挂起，挂起的线程的引用被放到waiters队列
    private BlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();


    @Override
    public boolean tryLock() {  //尝试获取锁
        //若锁未占用
        if (owner == null){
            owner = Thread.currentThread();     //当前线程获得锁
            return true;        //获得锁，返回true
        }else{
            return false;       //获取锁失败，返回false
        }
    }
    @Override
    public void lock() {
        while(!tryLock()){      //尝试拿锁，如果失败，
            Thread curTh = Thread.currentThread();      //获取当前线程引用
            waiters.offer(curTh);       //将当前线程引用放入等待队列

            LockSupport.park();     
           
        }
    }
    @Override
    public void unlock() {  //释放锁
        if (owner == Thread.currentThread()){       //若确实是我占有了锁
            owner = null;                           //将onwer置为null，释放锁
            Thread th = waiters.poll();     //取出队列头部的元素，并移除该元素
            LockSupport.unpark(th);           //唤醒队列头部的元素
        }
    }
  
}

这里只用一个owner来判断当前那个锁被占用 ，并用一个队列来存储阻塞线程

在ReentrantLock中去判断是否重入锁，需要添加State值。来判断当前锁是否被被占用

 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    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;
        }

 这里新加了个同步状态来维护，

实现的一个简单的可重入锁 

public class MyLock implements Lock {
    //锁拥有者
    volatile AtomicReference<Thread> owner = new AtomicReference<>();

    //等待队列
    private LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();

    //记录重入的次数
    volatile AtomicInteger state = new AtomicInteger(0);

  @Override
	public boolean tryLock() {
		int s = state.get();
		if (s != 0) {
			// 判断state是否为0，state！=0，说明锁被占用
			if (owner.get() == Thread.currentThread()) {
				state.set(s + 1);
				return true;
			}
		} else {
			// 如state==0，说明锁未未被占用，CAS操作来抢锁，修改state的值
			while (state.compareAndSet(s, s + 1)) {
				owner.set(Thread.currentThread());
				return true;
			}
		}
		return false;
	}

    @Override
    public void lock() {
        if (!tryLock()){
            waiters.offer(Thread.currentThread());

            //自旋抢锁
            for (;;){
                Thread head = waiters.peek();
        
                if (head == Thread.currentThread()){
                    if (!tryLock()){
                        LockSupport.park();
                    }else{
                        waiters.poll();
                        return;
                    }
                }else{
                    LockSupport.park();
                }
            }
        }
    }

    @Override
    public void unlock() {
        if (tryUnlock()){
            Thread th = waiters.peek();
            if (th !=null){
                LockSupport.unpark(th);
            }
        }
    }


    public boolean tryUnlock(){
        //判断owner是不是自己
        if (owner.get() != Thread.currentThread()){
            throw new IllegalMonitorStateException();
        }else{
            //释放锁，state-1，
            int ct = state.get();
            int nextc = ct -1;
            state.set(nextc);

            //是不是一定将onwer该问null
            if (nextc == 0){
                owner.set(null);
                return true;
            }else{
                return false;
            }
        }
    }

}

这里主要是为了实现一个简单的可重入锁，因此并没有考虑到其他情况

Condition