【并发专题】手写MyReentantLock_手写 reentrantlock

分析

ReentantLock的特点如下：

1. 首先是继承自AQS的
2. 可中断
3. 可以设置超时时间
4. 可以切换公平锁/非公平锁
5. 支持多个条件变量
6. 支持可重入

事实上，上面的很多东西AQS已经帮忙实现了，所以想要复刻一个不是很难。仔细观察一下源码，我们需要重写的接口只有以下几个：

1. 新建一个自己的MyReentrantLock类，实现了Lock接口
2. 在MyReentrantLock里面，新建一个NonfairSync类，继承自AbstractQueuedSynchronizer
3. 在NonfairSync里面需要实现如下接口：

void lock();
boolean tryAcquire();
boolean tryRelease();

至于为什么需要实现这三个接口，看如下注释：

总的来说：实现lock()是因为我们要实现可重入的话，需要自己写逻辑补充；
实现tryAcquire()，则是因为提供一种机制，让任务尽量可能在进入阻塞队列之前，能获取到锁。因为，进了阻塞队列之后可能会反复阻塞和解除阻塞（经历上下文切换），这个代价是昂贵的；
实现tryRelease()，则是因为这个方法是【释放锁】的核心方法。想要实现可重入的逻辑就得维护这个方法。

源码

为了方便，这里只是简单实现了一个非公平锁的代码。

public class MyReentrantLock implements Lock {

    /**
     * 锁实例
     */
    private NonfairSync sync;

    /**
     * 构造放啊
     */
    public MyReentrantLock() {
        sync = new NonfairSync();
    }

    @Override
    public void lock() {
        sync.lock();
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }

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

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

    /**
     * 非公平锁的实现方式
     */
    public static final class NonfairSync extends AbstractQueuedSynchronizer {

        /**
         * 非公平锁，上锁方法
         */
        public void lock() {

            // CAS操作锁
            boolean result = compareAndSetState(0, 1);
            if (result) {

                // 设置成功，则修改独占状态
                setExclusiveOwnerThread(Thread.currentThread());
            } else {

                // 设置不成功，则准备入等待队列
                acquire(1);
            }
        }

        /**
         * 实现AQS对tryAcquire的方法
         *
         * <p>
         * 以下是AQS的解释：
         * 以独占模式获取，忽略中断。通过调用至少一次tryAcquire实现，成功时返回。
         * 否则，线程将被排队，可能会反复阻塞和解除阻塞，调用tryAcquire直到成功。
         * 这个方法可以用来实现方法Lock.lock。
         * </p>
         */
        @Override
        protected boolean tryAcquire(int acquires) {
            return doTryAcquire(acquires);
        }

        /**
         * 实现AQS的tryRelease方法
         *
         * <p>
         * 通用场景
         * 术语库
         * 尝试将状态设置为在独占模式下反映释放。
         * 此方法总是由执行释放的线程调用。
         * 默认实现抛出UnsupportedOperationException。
         * 参数:
         * Arg -释放参数。该值始终是传递给释放方法的值，或者是进入条件等待时的当前状态值。否则该值是不解释的，可以表示您喜欢的任何内容。
         * 返回:
         * 如果该对象现在处于完全释放状态，则为True，以便任何等待的线程都可以尝试获取;否则为假。
         * 抛出:
         * IllegalMonitorStateException -如果释放会使同步器处于非法状态。此异常必须以一致的方式抛出，才能使同步正常工作。
         * UnsupportedOperationException -如果不支持独占模式
         * </p>
         */
        @Override
        protected boolean tryRelease(int releases) {
            final Thread thread = Thread.currentThread();
            if (thread != getExclusiveOwnerThread()) {
                throw new IllegalMonitorStateException();
            }

            int state = getState();
            int newState = state - releases;

            // 接口要求，完全释放则true，反之false
            boolean fullyRelease = false;
            if (newState == 0) {
                fullyRelease = true;
                setExclusiveOwnerThread(null);
            }

            setState(newState);
            return fullyRelease;
        }

        private ConditionObject newCondition() {
            return new ConditionObject();
        }

        /**
         * 实现非公平模式下的tryAcquire
         */
        private boolean doTryAcquire(int acquires) {
            final Thread currentThread = Thread.currentThread();
            int state = getState();
            if (state == 0) {

                // 再次竞争一下
                boolean result = compareAndSetState(0, acquires);
                if (result) {
                    setExclusiveOwnerThread(currentThread);
                    return true;
                }
            } else {

                // 判断是否为可重入
                Thread exclusiveOwnerThread = getExclusiveOwnerThread();
                if (exclusiveOwnerThread == currentThread) {

                    // 做可重入的逻辑
                    return doReentrantLock(state + acquires);
                }
            }

            return false;
        }

        private boolean doReentrantLock(int newState) {
            if (newState < 0) {
                throw new Error("可重入次数已达上限");
            }
            setState(newState);
            return true;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

使用示例

public class MyReentrantLockTest {

    // 票数
    public static int tickets = 8;

    // 总人数
    public static final int PERSONS = 10;

    public static final Lock LOCK = new MyReentrantLock();


    public static void main(String[] args) {

        for (int i = 0; i < PERSONS; i++) {
            new Thread(() -> {
                buyTicket();
            }).start();
        }
    }

    public static void main1(String[] args) {
        MyReentrantLock lock = new MyReentrantLock();
        lock.lock();
        try {
            System.out.println("试试看");
            lock.lock();
            try {
                System.out.println("可重入了");
            } finally {
                lock.unlock();
            }
        } finally {
            lock.unlock();
        }
    }


    public static void buyTicket() {
        // 获取锁
        LOCK.lock();
        try {
            Thread.sleep(1000);

            if(tickets > 0) {
                System.out.println("我是" + Thread.currentThread().getName() + "，我来抢第【" + tickets-- + "】张票");
            } else {
                System.out.println("我是" + Thread.currentThread().getName() + "，票卖完了我没抢到");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放说
            LOCK.unlock();
        }
    }

//    系统输出如下：
//    我是Thread-0，我来抢第【8】张票
//    我是Thread-1，我来抢第【7】张票
//    我是Thread-2，我来抢第【6】张票
//    我是Thread-3，我来抢第【5】张票
//    我是Thread-4，我来抢第【4】张票
//    我是Thread-5，我来抢第【3】张票
//    我是Thread-9，我来抢第【2】张票
//    我是Thread-7，我来抢第【1】张票
//    我是Thread-8，票卖完了我没抢到
//    我是Thread-6，票卖完了我没抢到
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69