JUC显式锁的原理与实战-04

public class LockSupportDemo {

    public static class ChangeObjectThread extends Thread {
        public ChangeObjectThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            Print.tco("即将进入无限时阻塞");
            // 阻塞当前线程
            LockSupport.park();
            if (Thread.currentThread().isInterrupted()) {
                Print.tco("被中断了，但任然会继续执行");
            } else {
                Print.tco("被重新唤醒了");
            }
        }
    }

    @Test
    public void testLockSupport() {
        ChangeObjectThread t1 = new ChangeObjectThread("线程一");
        ChangeObjectThread t2 = new ChangeObjectThread("线程二");
        //启动线程一
        t1.start();
        sleepSeconds(1);
        //启动线程二
        t2.start();
        sleepSeconds(1);
        //中断线程一
        t1.interrupt();
        // 唤醒线程二
        LockSupport.unpark(t2);
    }

    @Test
    public void testLockSupport2() {

        Thread t1 = new Thread(() ->
        {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Print.tco("即将进入无限时阻塞");
            //阻塞当前线程
            LockSupport.park();
            Print.tco("被重新唤醒了");

        }, "演示线程");
        t1.start();
        //唤醒一次没有使用 LockSupport.park()阻塞的线程
        LockSupport.unpark(t1);
        //再唤醒一次没有使用 LockSupport.park()阻塞的线程
        LockSupport.unpark(t1);
        sleepSeconds(2);
        //中断线程一
        //t1.interrupt();
        //第三唤醒使用 LockSupport.park()阻塞的线程
        LockSupport.unpark(t1);
    }
}

/**
 * CountDownLatch 共享锁的使用
 * 司机（Driver）在开车之前，需要100个乘客并发进行不重复的报数，报数到100之后说明人已经到齐，随后司机可以开车出发
 *
 * @author: wangyj
 * @create: 2022-04-20
 * @version: 1.0.0
 **/
public class Driver {

    private static final int N = 100; // 乘客数

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch doneSignal = new CountDownLatch(N);//取得CPU密集型线程池
        Executor e = ThreadUtil.getCpuIntenseTargetThreadPool();

        for (int i = 1; i <= N; ++i) // 启动报数任务
            e.execute(new Person(doneSignal, i));

        doneSignal.await(); //等待报数完成
        Print.tcfo("人数到期，开车");
    }

    static class Person implements Runnable {

        private final CountDownLatch doneSignal;
        private final int i;

        public Person(CountDownLatch doneSignal, int i) {
            this.doneSignal = doneSignal;
            this.i = i;
        }

        @Override
        public void run() {
            try {
                //报数
                Print.tcfo("第" + i + "个人以到");
                doneSignal.countDown();
            } catch (Exception ex) {
            } // return;
        }
    }
}

public class ReadWriteLockTest {

    //创建一个集合
    final static Map<String, String> MAP = new HashMap<String, String>();
    //创建一个读写锁
    final static ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock();
    //获取读锁
    final static Lock READ_LOCK = LOCK.readLock();
    //获取写锁
    final static Lock WRITE_LOCK = LOCK.writeLock();

    //写操作
    public static Object put(String key, String value) {
        WRITE_LOCK.lock();
        try {
            Print.tco(DateUtil.getNowTime() + " 抢占了WRITE_LOCK，开始执行write操作");
            Thread.sleep(1000);
            String put = MAP.put(key, value);
//            Print.tco("write操作执行完毕");
            return put;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            WRITE_LOCK.unlock();
        }
        return null;
    }

    //读操作
    public static Object get(String key) {
        READ_LOCK.lock();
        try {
            Print.tco(DateUtil.getNowTime() + " 抢占了READ_LOCK，开始执行read操作");
            Thread.sleep(1000);
            String value = MAP.get(key);
//            Print.tco("read操作执行完毕");
            return value;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            READ_LOCK.unlock();
        }
        return null;
    }

    public static void main(String[] args) {
        //创建Runnable可执行实例
        Runnable writeTarget = () -> put("key", "value");
        Runnable readTarget = () -> get("key");

        //创建4条读线程
        for (int i = 0; i < 4; i++) {
            new Thread(readTarget, "读线程" + i).start();
        }
        //创建2条写线程，并启动
        for (int i = 0; i < 2; i++) {
            new Thread(writeTarget, "写线程" + i).start();
        }
    }
}

public class ReadWriteLockTest2 {

    //创建一个集合
    final static Map<String, String> MAP = new HashMap<String, String>();
    //创建一个读写锁
    final static ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock();
    //获取读锁
    final static Lock READ_LOCK = LOCK.readLock();
    //获取写锁
    final static Lock WRITE_LOCK = LOCK.writeLock();

    //写操作
    public static Object put(String key, String value) {
        WRITE_LOCK.lock();
        try {
            Print.tco(DateUtil.getNowTime() + " 抢占了WRITE_LOCK，开始执行write操作");
            Thread.sleep(1000);
            String put = MAP.put(key, value);
            Print.tco(Thread.currentThread().getName() + "尝试降级写锁为读锁");
            //写锁降级为读锁（成功）
            READ_LOCK.lock();
            Print.tco(Thread.currentThread().getName() + "写锁降级为读锁成功");
            return put;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            READ_LOCK.unlock();
            WRITE_LOCK.unlock();
        }
        return null;
    }

    //读操作
    public static Object get(String key) {
        READ_LOCK.lock();
        try {
            Print.tco(DateUtil.getNowTime() + " 抢占了READ_LOCK，开始执行read操作");
            Thread.sleep(1000);
            String value = MAP.get(key);
            Print.tco(Thread.currentThread().getName() + "尝试升级读锁为写锁");
            //读锁升级为写锁(失败)
            WRITE_LOCK.lock();
            Print.tco(Thread.currentThread().getName() + "读锁升级为写锁成功");

            return value;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            READ_LOCK.unlock();
        }
        return null;
    }

    public static void main(String[] args) {
        //创建Runnable可执行实例
        Runnable writeTarget = () -> put("key", "value");
        Runnable readTarget = () -> get("key");
        //创建1条写线程，并启动

        new Thread(writeTarget, "写线程").start();

        //创建1条读线程

        new Thread(readTarget, "读线程").start();
    }
}

public class CLHLock implements Lock {

    /**
     * 指向当前节点
     */
    private static ThreadLocal<Node> curNodeLocal = new ThreadLocal();
    private String name;
    /**
     * CLHLock队列的尾部
     * tail属性使用AtomicReference类型是为了使得多个线程并发操作tail时不会发生线程安全问题
     */
    private AtomicReference<Node> tail = new AtomicReference<>();

    public CLHLock() {
        // 设置尾部节点
        tail.getAndSet(Node.EMPTY);
    }

    public CLHLock(String name) {
        this.name = name;
        // 设置尾部节点
        tail.getAndSet(Node.EMPTY);
    }

    //加锁：将节点添加到等待队列的尾部
    @Override
    public void lock() {
        Node curNode = new Node(true, null);
        Node preNode = tail.get();
        //CAS自旋：将当前节点插入到队列的尾部
        while (!tail.compareAndSet(preNode, curNode)) {
            preNode = tail.get();
        }
        //设置前驱
        curNode.setPreNode(preNode);
        //监听前驱节点的locked变量，直到其值为false
        //若前继节点的locked状态为true，则表示前一线程还在抢占或者占有锁
        while (curNode.getPreNode().isLocked()) {
            //让出CPU时间片，提高性能
            Thread.yield();
        }
        // 能执行到这里，说明当前线程获取到了锁
        //  Print.tcfo("获取到了锁！！！");

        //设置在线程本地变量中，用于释放锁
        curNodeLocal.set(curNode);
    }

    @Override
    public void unlock() {
        Node curNode = curNodeLocal.get();
        curNode.setPreNode(null);   //help for GC
        curNodeLocal.set(null);
        curNode.setLocked(false);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        throw new IllegalStateException(
                "方法 'lockInterruptibly' 尚未实现!");
    }

    @Override
    public boolean tryLock() {
        throw new IllegalStateException(
                "方法 'tryLock' 尚未实现!");
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        throw new IllegalStateException(
                "方法 'tryLock' 尚未实现!");
    }

    @Override
    public Condition newCondition() {
        throw new IllegalStateException(
                "方法 'newCondition' 尚未实现!");
    }

    @Override
    public String toString() {
        return "CLHLock{" + name + '}';
    }

    @Data
    static class Node {
        //true：当前线程正在抢占锁、或者已经占有锁
        // false：当前线程已经释放锁，下一个线程可以占有锁了
        volatile boolean locked;
        //前一个节点，需要监听其locked字段
        Node preNode;

        public Node(boolean locked, Node preNode) {
            this.locked = locked;
            this.preNode = preNode;
        }

        //空节点
        public static final Node EMPTY =
                new Node(false, null);
    }
}