手写简单版 ReenrantLock

手写简单版 ReenrantLock

package ReenrantLock;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;

public class MyLock implements Lock {

    private AtomicInteger state = new AtomicInteger();

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

    private Thread ownerThread = null;

    @Override
    public void lock() {

        if(!tryLock()) {//tryLock才是真正的锁，获得锁是在tryLock中

            //没有获得锁，放入队列
            waiters.add(Thread.currentThread());

            for (;;) {//重试获得锁，被唤醒就重试
                if(tryLock()) { //获得了锁，但进入这里说明前面已经排队，出队
                    waiters.poll();
                    return;
                } else {
                    LockSupport.park();
                }

            }


        }

    }

    @Override
    public boolean tryLock() {

        if( state.get() == 0 ) {// 0 表示是空闲锁
            if( state.compareAndSet(0, 1) ) {//设置成功才是真的锁上
                ownerThread = Thread.currentThread();
                return true;
            }
        }else if ( ownerThread == Thread.currentThread() ) {
            //state 不为1，且线程一样，即发生了重入，更新state
            state.addAndGet(1);
            System.out.println("发生了重入"+ state);
            return true;
        }
        return false;
    }

    @Override
    public void unlock() {
        if( Thread.currentThread() != ownerThread ) {
            throw new RuntimeException("非法调用不成功");
        }
        if(state.decrementAndGet() == 0) { //等于 0 才是真正的释放锁
            ownerThread = null;
            //通知队列中第一个线程
            Thread firstThread = waiters.peek();
            if( firstThread != null ) {
                LockSupport.unpark(firstThread);
            }

        }

    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws
            InterruptedException {
        return false;
    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

关键点：
1、tryLock 使用 AtomicInteger CAS 无锁方式实现锁
2、ownerThread == Thread.currentThread() 判断是否重入
3、unlock(),state.decrementAndGet() == 0 才是真正释放锁

测试类

package TestMyReenrantLock;

import ReenrantLock.MyLock;

public class test {
    public static void main(String[] args) {

        try {
            method3();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread( ()-> method2()).start();

    }

    private static MyLock lock = new MyLock();

    public static void method1() {

        lock.lock();
        System.out.println( "method1获得了锁... "+ Thread.currentThread());
        lock.unlock();
    }

    public static void method2() {

        lock.lock();
        System.out.println( "method2获得了锁... "+ Thread.currentThread());
        lock.unlock();
    }

    public static void method3() throws InterruptedException {

        lock.lock();
        System.out.println( "method3获得了锁... " + Thread.currentThread());
        method1();
        Thread.sleep(2000);
        lock.unlock();
    }
}