Lock锁的详细实现(AQS及Future Task)

public class ReentrantDemo1 {
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        lock.lock();  // block until condition holds
        try {
            System.out.println("第一次获取锁");
            System.out.println("当前线程获取锁的次数" + lock.getHoldCount());
            lock.lock();
            System.out.println("第二次获取锁了");
            System.out.println("当前线程获取锁的次数" + lock.getHoldCount());
        } finally {
            lock.unlock();
            lock.unlock();
        }
        System.out.println("当前线程获取锁的次数" + lock.getHoldCount());

        // 如果不释放，此时其他线程是拿不到锁的
        new Thread(() -> {
            System.out.println(Thread.currentThread() + " 期望抢到锁");
            lock.lock();
            System.out.println(Thread.currentThread() + " 线程拿到了锁");
        }).start();
    }
}

// 可响应中断
public class LockInterruptiblyDemo1 {
    private Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        LockInterruptiblyDemo1 demo1 = new LockInterruptiblyDemo1();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    demo1.test(Thread.currentThread());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        thread1.start();
        Thread.sleep(500); // 等待0.5秒，让thread1先执行

        thread2.start();
        Thread.sleep(2000); // 两秒后，中断thread2

        thread2.interrupt();
    }

    public void test(Thread thread) throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "， 想获取锁");
        lock.lockInterruptibly();   //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
        try {
            System.out.println(thread.getName() + "得到了锁");
            Thread.sleep(10000); // 抢到锁，10秒不释放
        } finally {
            System.out.println(Thread.currentThread().getName() + "执行finally");
            lock.unlock();
            System.out.println(thread.getName() + "释放了锁");
        }
    }
}

// 缓存示例
public class CacheDataDemo {
    // 创建一个map用于缓存
    private Map<String, Object> map = new HashMap<>();
    private static ReadWriteLock rwl = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        // 1 读取缓存里面的数据
        // cache.query()
        // 2 如果换成没数据,则取数据库里面查询  database.query()
        // 3 查询完成之后,数据塞到塞到缓存里面 cache.put(data)
    }

    public Object get(String id) {
        Object value = null;
        // 首先开启读锁，从缓存中去取
        rwl.readLock().lock();
        try {
            if (map.get(id) == null) {
                // TODO database.query();  全部查询数据库 ,缓存雪崩
                // 必须释放读锁
                rwl.readLock().unlock();
                // 如果缓存中没有释放读锁，上写锁。如果不加锁，所有请求全部去查询数据库，就崩溃了
                rwl.writeLock().lock(); // 所有线程在此处等待  1000  1  999 (在同步代码里面再次检查是否缓存)
                try {
                    // 双重检查，防止已经有线程改变了当前的值，从而出现重复处理的情况
                    if (map.get(id) == null) {
                        // TODO value = ...如果缓存没有，就去数据库里面读取
                    }
                    rwl.readLock().lock(); // 加读锁降级写锁,这样就不会有其他线程能够改这个值，保证了数据一致性
                } finally {
                    rwl.writeLock().unlock(); // 释放写锁@
                }
            }
            
        /* 在这里又进行了一系列操作，在操作过程中，有可能数据改变导致缓存内容改变
           此时，要在写锁中加入读锁，防止类似于 幻读，脏读 等的产生
        */
           
        } finally {
            rwl.readLock().unlock();
        }
        return value;
    }
}

/**
 * 自己手动实现的一个 reentrantLock
 *
 */
public class GzyLock  implements Lock {

    //需要 CAS 自旋的方式去实现
    //模仿 monitor obj 的重量级锁 有一个 owner
    private static AtomicReference<Thread> owner = new AtomicReference<>();

    private static LinkedBlockingDeque<Thread> waiters = new LinkedBlockingDeque<>();

    @Override
    public void lock() {
        boolean addQueue = true;
        while (!tryLock()){
            //第一次进来会放到queue
            if(addQueue) {
                //如果没有获取到锁，就先存到 queue
                waiters.offer(Thread.currentThread());
                addQueue = false;
            }else {
                //park 等待被唤醒。这里不能用 wait/notify 因为需要在同步代码块用
                LockSupport.park();
            }
            //唤醒后尝试争抢，没抢到继续等
        }
        //抢到锁，移除掉
        waiters.remove(Thread.currentThread());
    }
    @Override
    public boolean tryLock() {
        //适用当前线程尝试加锁
        return owner.compareAndSet(null, Thread.currentThread());
    }

    @Override
    public void unlock() {
        //unlock 的时候，要唤醒等待线程
        //如果释放锁成功了，才会唤起
        //这里用 if 是因为，一定不会出现 循环
        if (owner.compareAndSet(Thread.currentThread(), null)) {
            //一次唤醒所有在等待队列的
            for (Thread waiter : waiters) {
                //唤起等待队列的线程
                LockSupport.unpark(waiter);
            }
        }
    }

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

        Adder adder = new Adder();
        for (int j = 0; j < 10; j++) {
            Thread addThread = new Thread(() -> {
                for (int i = 0; i < 1000; i++) {
                    adder.add();
                }
            });
            addThread.start();;
        }
        Thread.sleep(1000L);
        System.out.println(adder.i);
    }

    static class Adder{

        Lock lock = new GzyLock();
        int i = 0;
        public void add(){
            lock.lock();
            try {
                i++;
            }finally {
                lock.unlock();
            }
        }
    }
}