首页 > itarticle > javacurrency锁的实现

javacurrency锁的实现

admin 11月 12, 2020 0

读写锁(ReentrantReadWriteLock)

protected final boolean (int acquires) {
           Thread current = Thread.currentThread();
           int c = getState();
           int w = exclusiveCount(c);
           if (c != 0) {
             
             //如果c!=0 && w!=0 ，那么肯定不存在读锁，只需判断当前写锁是否是当前线程即可
               if (w == 0 || current != getExclusiveOwnerThread())
                   return false;
               if (w + exclusiveCount(acquires) > MAX_COUNT)
                   throw new Error("Maximum lock count exceeded");
               //上述判断全部通过，肯定是重入锁
               setState(c + acquires);
               return true;
           }
           if (writerShouldBlock() ||
               !compareAndSetState(c, c + acquires))
               return false;
           setExclusiveOwnerThread(current);
           return true;
       }

ConcurrentLinkedQueue

public boolean offer(E e) {
    checkNotNull(e);
    final Node<E> newNode = new Node<E>(e);
    for (Node<E> t = tail, p = t;;) {
        Node<E> q = p.next;
        if (q == null) {
            // p是尾节点
            if (p.casNext(null, newNode)) {
                // Successful CAS is the linearization point
                // for e to become an element of this queue,
                // and for newNode to become "live".
                if (p != t) // hop two nodes at a time
                    casTail(t, newNode);  // Failure is OK.
                return true;
            }
            // Lost CAS race to another thread; re-read next
        }
        else if (p == q)
            // We have fallen off list.  If tail is unchanged, it
            // will also be off-list, in which case we need to
            // jump to head, from which all live nodes are always
            // reachable.  Else the new tail is a better bet.
            p = (t != (t = tail)) ? t : head;
        else
            // Check for tail updates after two hops.
            p = (p != t && t != (t = tail)) ? t : q;
    }
}