一、前置准备条件

我们需要知道如何进行比较并交换的原子操作、如何进行线程的挂起和唤醒。
（1）Unsafe中的CAS
（2）Unsafe中的park和unpark

二、一个错误的锁

package com.suncy.article.article6;

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.LinkedBlockingQueue;

public class ErrorLockCode {
    private int state = 0;
    private LinkedBlockingQueue<Thread> threadLinkedBlockingQueue = new LinkedBlockingQueue<Thread>();

    //unsafe包 和 state字段的偏移量
    private static final Unsafe unsafe;
    private static final long stateOffset;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            unsafe = (Unsafe) f.get(null);
            stateOffset = unsafe.objectFieldOffset
                    (ErrorLockCode.class.getDeclaredField("state"));
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }

    public void lock() {
        if (!unsafe.compareAndSwapInt(this, stateOffset, 0, 1)) {
            //修改state失败，获取锁失败，线程加入队列，等待被唤醒
            threadLinkedBlockingQueue.add(Thread.currentThread());
            unsafe.park(false, 0);
            threadLinkedBlockingQueue.poll();
        }
    }

    public void unlock() {
        if (unsafe.compareAndSwapInt(this, stateOffset, 1, 0)) {
            //修改state成功，表示解锁成功，唤醒线程
            Thread thread = threadLinkedBlockingQueue.peek();
            unsafe.unpark(thread);
        }
    }

    public static void main(String[] args) {
        ErrorLockCode errorLockCode = new ErrorLockCode();
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            new Thread(() -> {
                errorLockCode.lock();
                System.out.println("==========" + finalI);
                System.out.println("加锁成功" + finalI);
                System.out.println("执行业务" + finalI);
                System.out.println("解锁成功" + finalI);
                System.out.println("==========" + finalI);
                errorLockCode.unlock();
            }).start();
        }
    }
}

测试结果：

image.png

流程描述：
1、在lock方法中，尝试修改state状态0，修改成功，则表示锁成功。修改失败，则将线程放入到队列，并使用park挂起当前线程。
2、在unlock方法中，尝试修改state状态1，修改成功，则表示解锁，并唤醒线程中队头的数据。修改失败，不进行任何处理。

错误原因分析：
我们第一个线程肯定是成功的，但当第一个线程进行了unlock方法的时候，这个unlock会唤醒一个线程，假如这个时候又重新启了一个线程，那么会造成两个线程同时执行到lock和unlock当中的代码，导致锁失效

解决方式：
唤醒的线程需要重新获取锁

三、一个不可重入锁

package com.suncy.article.article6;

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.LinkedBlockingQueue;

public class MyNotReentrantLock {
    private volatile int state = 0;
    private LinkedBlockingQueue<Thread> linkedBlockingQueue = new LinkedBlockingQueue<Thread>(3333);

    //unsafe包 和 state字段的偏移量
    private static final Unsafe unsafe;
    private static final long stateOffset;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            unsafe = (Unsafe) f.get(null);
            stateOffset = unsafe.objectFieldOffset
                    (MyNotReentrantLock.class.getDeclaredField("state"));

        } catch (Exception ex) {
            throw new Error(ex);
        }
    }

    public void lock() {
        while (!unsafe.compareAndSwapInt(this, stateOffset, 0, 1)) {
            //失败，线程加入队列，等待精准唤醒
            //System.out.println("线程入队");
            linkedBlockingQueue.add(Thread.currentThread());
            unsafe.park(false, 0);
            linkedBlockingQueue.remove(Thread.currentThread());
        }
    }

    public void unlock() {
        //成功，表示解锁
        if (unsafe.compareAndSwapInt(this, stateOffset, 1, 0)) {
            //唤醒队列中的线程 不需要删除 只需要查看就行 因为被唤醒之后，会自动移除队列数据
            Thread th = linkedBlockingQueue.peek();
            if (th != null) {
                unsafe.unpark(th);
            }
        }
    }

    public static void main(String[] args) {
        MyNotReentrantLock myNotReentrantLock = new MyNotReentrantLock();
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            new Thread(() -> {
                myNotReentrantLock.lock();
                System.out.println("==========" + finalI);
                System.out.println("加锁成功" + finalI);
                System.out.println("执行业务" + finalI);
                System.out.println("解锁成功" + finalI);
                System.out.println("==========" + finalI);
                myNotReentrantLock.unlock();
            }).start();
        }
    }
}

执行结果：

image.png

结果分析：
1、在lock方法中，唤醒的线程重新去抢锁，这个时候保证了在unlock之后唤醒的线程和重新启动的线程重新抢锁，满足了要求。
2、但是这个锁是不可重入的，假如我们同时执行两遍lock方法，就会导致线程死锁，修改方式为判断是否是当前线程，并记录数量。

四、一个可重入的锁

package com.suncy.article.article6;

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicReference;

public class MyReentrantLock {

    private volatile int state = 0;
    AtomicReference<Thread> owner = new AtomicReference<>();
    private LinkedBlockingQueue<Thread> linkedBlockingQueue = new LinkedBlockingQueue<>();

    //unsafe包 和 state字段的偏移量
    private static final Unsafe unsafe;
    private static final long stateOffset;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            unsafe = (Unsafe) f.get(null);
            stateOffset = unsafe.objectFieldOffset
                    (MyNotReentrantLock.class.getDeclaredField("state"));
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }

    public boolean tryLock() {
        int c = state;

        //如果count不等于0，说明存在锁
        if (c != 0) {
            //判断是不是当前线程持有锁
            if (owner.get() == Thread.currentThread()) {
                state = c + 1;
                //加锁成功
                return true;
            } else {
                //加锁失败
                return false;
            }
        } else {
            //count等于0，说明不存在锁
            if (unsafe.compareAndSwapInt(this, stateOffset, c, c + 1)) {
                //抢锁成功，设置owner为当前线程的引用
                owner.set(Thread.currentThread());
                return true;
            } else {
                //加锁失败
                return false;
            }
        }
    }

    public void lock() {
        //尝试抢锁
        while (!tryLock()) {
            //如果失败，放入到队列中
            linkedBlockingQueue.offer(Thread.currentThread());
            //并挂起
            unsafe.park(false, 0);
            //唤醒之后，则从队列中移除，并重新抢锁
            linkedBlockingQueue.remove(Thread.currentThread());
        }
    }

    public void unlock() {
        //解锁成功
        if (tryUnlock()) {
            //唤醒队列中的线程
            Thread th = linkedBlockingQueue.peek();
            if (th != null) {
                unsafe.unpark(th);
            }
        }
    }

    public boolean tryUnlock() {
        if (owner.get() != Thread.currentThread()) {
            throw new IllegalMonitorStateException();
        } else {
            //如果当前线程占有锁，则将计数减1
            state--;
            //判断count值是否为0,0的话，设置owner为null
            if (state == 0) {
                owner.compareAndSet(Thread.currentThread(), null);
                return true;
            } else {
                return false;
            }
        }
    }

    public static void main(String[] args) {
        MyReentrantLock myReentrantLock = new MyReentrantLock();
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            new Thread(() -> {
                myReentrantLock.lock();
                myReentrantLock.lock();
                System.out.println("==========" + finalI);
                System.out.println("加锁成功" + finalI);
                System.out.println("执行业务" + finalI);
                System.out.println("解锁成功" + finalI);
                System.out.println("==========" + finalI);
                myReentrantLock.unlock();
                myReentrantLock.unlock();
            }).start();
        }
    }
}

执行结果：

image.png

结果分析：
结果正常，并且执行两遍lock方法也能够运行。