ReentrantLock学习笔记

lock

		final void lock() {
			//当state的值是0的时候，就不会涉及到队列的问题，仅仅只是队state值的改变和owner的设置
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
            //失败进行抢占
                acquire(1);
		}
		
	public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
	
	
	
	//非公平锁的抢占方式
 	final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //获取状态量
            int c = getState();
			//装填量为0  可以抢占
            if (c == 0) {
            	//尝试抢占  
            	//请注意，这里是公平锁和非公平锁的第一个不同地方  如果是公平锁会查看阻塞队列中是否有数据，再进行抢占数据
                if (compareAndSetState(0, acquires)) {
                	//更新锁的拥有者
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //因为是可重入锁 当前一个线程再次进入的时候不需要从新抢占，只需要更改状态偏移量
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
	
	//入阻塞队列
	private Node addWaiter(Node mode) {
		//新建节点
        Node node = new Node(Thread.currentThread(), mode);
		
		//尾插法
        Node pred = tail;
        if (pred != null) {
        //先指向前驱节点  再通过cas的方式从新设置尾节点
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //到这一步失败的原因是  阻塞队列为空 或者  cas设置尾结点失败
        enq(node);
        return node;
    }
	
	//兜底的入队方式
	private Node enq(final Node node) {
		//要么成功  要么我就一直不停
        for (;;) {
            Node t = tail;
            //如果是队列为空，那么就新建队列，并且设置为  头节点
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
				//常规尾插入队，要么成功  要么循环不停止
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }



	//以独占的方式获取队列
	final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            //要么成功  要么一直执行
            for (;;) {
				//获取当前节点的前驱节点
                final Node p = node.predecessor();
				//如果前驱节点是头节点  那么就说明就只有一个节点  
                if (p == head && tryAcquire(arg)) {	
					//从新设置头节点
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

	//这个函数的主要作用是 更新状态量
	private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }
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

分享和记录一个大佬写的笔记：
https://funzzz.fun/2021/05/13/AQS%E8%AF%A6%E8%A7%A3/