利用AQS实现自定义锁

    利用AQS实现自定义锁，只需要自定义实现一个同步器，重写AQS中两个方法tryAcquire和tryRelease，如果是 共享锁的话则只需重写tryAcquireShared和tryReleaseShared两个方法，如果需要实现Condition效果则需要另外 重写isHeldExclusively方法。

package com.aqs;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 自定义同步器实现
 * @date 2020/9/10
 */
public class MyLock implements Lock {

    private Sync sync;

    public MyLock() {
        sync = new Sync();
    }

    @Override
    public void lock() {
        sync.acquire(1);
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "尝试获取锁，状态为" + thread.getState());
    }

    @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 false;
    }

    @Override
    public void unlock() {
        sync.release(1);
    }

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }

    private class Sync extends AbstractQueuedSynchronizer {
        /**
         * 需要实现Condition效果则需要另外
         * 重写isHeldExclusively方法
         * @return
         */
        @Override
        protected boolean isHeldExclusively() {
            //是否处于占用状态
            return getState() == 1;
        }

        @Override
        protected boolean tryAcquire(int arg) {
            Thread thread = Thread.currentThread();
            int c = getState();
            // 无锁状态 可以直接获取锁
            if (c == 0) {
                // 如果没有前继节点（自己就是头结点） 则尝试直接获取锁
                if (!hasQueuedPredecessors() && compareAndSetState(0, arg)) {
                    // 设置占有锁的线程
                    setExclusiveOwnerThread(thread);
                    System.out.println(Thread.currentThread().getName() + "获取到锁");
                    return true;
                }

            } else {
                // 有锁状态 竞争
                int state = c + arg;
                // 如果是当前线程 则可重入
                if (getExclusiveOwnerThread() == thread) {
                    setState(state);
                    System.out.println(Thread.currentThread().getName() + "重入获取到锁");
                    return true;
                }
            }
            // acquire方法 如果tryAcquire失败 会将当前线程加入同步队列中
            System.out.println(Thread.currentThread().getName() + "尝试获取锁失败");
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {
            int c = getState() - arg;
            boolean free = false;
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                throw new IllegalMonitorStateException();
            }
            // 因为存在可重入锁  加几次锁就需要解几次锁 否则会一直阻塞 当state为0时锁才会全部释放
            if (c == 0) {
                free = true;
                // 设置占有线程为空
                setExclusiveOwnerThread(null);
                System.out.println(Thread.currentThread().getName() + "释放锁");
            }
            // 设置状态
            setState(c);
            return free;
        }
        Condition newCondition() {
            return new ConditionObject();
        }
    }

}

 测试方法：

package com.aqs;

import java.util.concurrent.locks.Condition;

/**
 * @date 2020/9/10
 */
public class MyLockTest {

    private static int count = 0;


    public static void main(String[] args) {
        testMyLock();
    }

    public static void testMyLock(){
        MyLock myLock = new MyLock();
        /**
         * Condition接口提供了类似Object(wait()/notify())的监视器方法，与Lock配合可以实现等待/通知模式,一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现
         */
        Condition condition = myLock.newCondition();
        new Thread(() -> {
            myLock.lock();
            try {
                System.out.println("进入等待!");
                /**
                 * 当调用await()方法后，当前线程会释放锁并在此等待而,其他线程调用Condition对象的signal()方法，通知当前线程后，当前线程才从await()方法返回，并且在返回前已经获取了锁。
                 * 造成当前线程在接到信号或被中断之前一直处于等待状态
                 */
                condition.await(); // 释放锁
                System.out.println("接收到通知！继续执行！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 100; i++) {
                count += 1;
                System.out.println(Thread.currentThread().getName() + ", count = " + count);
            }
            myLock.unlock();

        }).start();

        new Thread(() -> {
            myLock.lock();
            try {
                System.out.println("进入等待!");
                /**
                 * 当调用await()方法后，当前线程会释放锁并在此等待而,其他线程调用Condition对象的signal()方法，通知当前线程后，当前线程才从await()方法返回，并且在返回前已经获取了锁。
                 * 造成当前线程在接到信号或被中断之前一直处于等待状态
                 */
                condition.await(); // 释放锁
                System.out.println("接收到通知！继续执行！");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 100; i++) {
                count += 1;
                System.out.println(Thread.currentThread().getName() + ", count = " + count);
            }
            myLock.unlock();

        }).start();

        new Thread(() -> {
            try {
                System.out.println("模拟3秒后发送通知过！");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myLock.lock();
            for (int i = 0; i < 100; i++) {
                count += 1;
                System.out.println(Thread.currentThread().getName() + ", count = " + count);
            }
            /**
             * 唤醒一个等待线程。该线程从等待方法返回前必须获得与Condition相关的锁。
             * 将会唤醒在等待队列中等待最长时间的节点（条件队列里的首节点）(类似于公平锁)
             */
            condition.signal();
            //signalAll唤醒所有等待线程
            //condition.signalAll();
            myLock.unlock();
        }).start();
    }
}

 Condition参考文章：https://www.cnblogs.com/gemine/p/9039012.html

AQS参考文章：https://blog.csdn.net/weixin_38106322/article/details/107116570

                          https://www.cnblogs.com/waterystone/p/4920797.html