Lock介绍

ChatGPT 可用网址，仅供交流学习使用，如对您有所帮助，请收藏并推荐给需要的朋友。
https://ckai.xyz

Lock介绍

Lock是juc(java.util.concurrent)包下面的一个接口类,是作者Doug Lea定义的api规范,主要接口有

Condition介绍

Condition也是juc包下的一个接口类,需要在线程持有Lock的状态下操作该接口下的方法,主要接口有

作用

Lock通过lock,trylock和unlock接口操作,可以保证在多线程环境下的代码块的同步执行,保证执行结果的正确性.通过Condition的await和signal,signallAll操作,保证同步代码块中的条件得到满足才能被执行完成.提示代码如下:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockAndConditionDemo {
    private List<String> containers = new ArrayList<>();
    private int capacity = 10;

    private Lock lock = new ReentrantLock();
    private Condition emptyCondition = lock.newCondition();
    private Condition fullCondition = lock.newCondition();

    public void add(String product) {
        lock.lock();
        try {
            while (containers.size() == capacity) {
                fullCondition.await();
            }
            containers.add(product);
            emptyCondition.signalAll();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

    public String take() {
        lock.lock();
        String product = null;
        try {
            while (containers.size() == 0) {
                emptyCondition.await();
            }
            product = containers.remove(0);
            fullCondition.signalAll();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();

        }
        return product;
    }
}

ReentrantLock介绍

ReentrantLock也是juc包下的一个具体类,它实现了Lock的接口.通常也用它来作为Lock接口的具体实现类,内部通过静态内部类Sync继承AQS(AbstractQueuedSynchronizer)父类来实现Lock的lock方法.
AQS内部是一个同步等待队列,它通过state(状态计数位)和CAS(compareAndSetState)乐观锁的方式实现同步,底层是通过unsafe的本地方法unsafe.compareAndSwapInt来保证操作的原子性的.队列是通过属性head,tail和静态内部类Node的属性prev,next来实现的双向队列,通过enq方法将新包装的Thread的Node节点添加到末尾.
简要分析下ReentrantLock.lock()的源代码:

//方法一:
public void lock() {
    //通过sync内部类lock方法,默认为非公平
    sync.lock();
}
//方法二:
final void lock() {
    //通过cas乐观锁方式设置锁对象属性state的值,默认值为0
    if (compareAndSetState(0, 1))
        //成功设置为1进入此方法
        setExclusiveOwnerThread(Thread.currentThread());
    else
        //失败进入此方法
        acquire(1);
}

//方法三:
protected final boolean compareAndSetState(int expect, int update) {
    // 通过unsafe保证操作原子性
    //stateOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("state"));state的属性的地址值
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

方法四:
//就是一个set设置属性的方法,该类AbstractOwnableSynchronizer是AQS的父类
//为真到方法四执行完成lock方法就完成了
protected final void setExclusiveOwnerThread(Thread thread) {
    exclusiveOwnerThread = thread;
}

方法五:
public final void acquire(int arg) {
    //tryAcquire方法再次尝试获取state的值,获取成功就退出,不成功执行acquireQueued方法
    //addWaiter方法
    //acquireQueued方法
    //selfInterrupt方法
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

方法六:
//调用nonfairTryAcquire方法
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

方法七:
final boolean nonfairTryAcquire(int acquires) {
    //获取当前线程
    final Thread current = Thread.currentThread();
    //获取AQS当前属性state值
    int c = getState();
    //如果c变为0了,说明第一次CAS操作的state值已经被获取锁的线程修改为0了
    if (c == 0) {
        //再次调用方法三
        if (compareAndSetState(0, acquires)) {
            //成功则再次调用方法四,同样lock方法也执行完成了,true之后就不会执行&&后面的方法了
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //如果不为0,判断当前线程是否和锁对象保存的thread属性一致,如果相等说明是同一个线程,之前的锁还没有释放的情况,可以重入
    else if (current == getExclusiveOwnerThread()) {
        //当前state值+1,如果超过了int的最大值,则到达了重入的边界值抛出异常中断该线程后续执行
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        //设置state属性值后lock方法也执行完了
        setState(nextc);
        return true;
    }
    return false;
}

方法八:
//方法参数为static final Node EXCLUSIVE = null;
private Node addWaiter(Node mode) {
    //创建AQS的静态内部类的node实例       
    // Node(Thread thread, Node mode) {     
            // Used by addWaiter
    //        this.nextWaiter = mode;
    //        this.thread = thread;
    //    }
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        //新加入的节点的上一个节点为该lock对象的AQS的对尾
        node.prev = pred;
        //通过CAS的方式保证AQS的对尾节点设置为新节点,成功则将原对尾节点的下一个节点为新加入的节点返回该节点,然后开始执行acquireQueued方法,不成功进入enq方法
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 将当前节点添加到AQS队列的末尾并设置尾节点尾当前节点
    enq(node);
    return node;
}

方法九:
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            //获取新创建节点的前一个节点对象
            final Node p = node.predecessor();
            //如果上一个节点为头节点,则说明前面已经没有等待node了,则再次执行方法七
            if (p == head && tryAcquire(arg)) {
                //成功则设置该node为头节点,断开原先头节点指向该节点的引用链接
                //不执行cancelAcquire方法
                //不执行selfInterrupt方法,同时lock方法也执行完成了
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //方法七没有设置成功,则执行阻塞该线程的方法
            //成功则执行阻塞和检查线程是否被中断的方法
            //线程是被中断的则打断标识位设置为true,继续循环执行,否则打断标志为false继续执行
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            //非正常退出循环会执行获取失败会执行取消获取节点方法
            cancelAcquire(node);
    }
}

方法十:
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //获取上一个节点的等待状态
    int ws = pred.waitStatus;
    //如果为-1则为true退出,执行暂停和检查打断方法parkAndCheckInterrupt()
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    //如果大于0,则找到上一个节点之前的节点的等待状态值大于0的前节点
    //并将该节点的下一个节点引用设置为该节点,退出继续循环执行上个方法
    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.
         */
        //如果ws值为0,则通过cas设置等待状态的值为-1,退出继续循环执行上个方法
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

方法十一:
private final boolean parkAndCheckInterrupt() {
    //线程阻塞方法
    LockSupport.park(this);
    //获取线程是否被打断的状态返回,返回之后线程状态会被重置
    return Thread.interrupted();
}

方法十二:
public static void park(Object blocker) {
    //获取当前线程
    Thread t = Thread.currentThread();
    //通过unsafe类将线程parkBlock设置为该lock对象
    setBlocker(t, blocker);
    //UNSAFE.park是阻塞线程的方法
    UNSAFE.park(false, 0L);
    //重新将线程parkBlock设置为null
    setBlocker(t, null);
}

方法十三:
private static void setBlocker(Thread t, Object arg) {
    // Even though volatile, hotspot doesn't need a write barrier here.
    //对应parkBlockerOffset放置lock对象
    UNSAFE.putObject(t, parkBlockerOffset, arg);
}

方法十四:
private void cancelAcquire(Node node) {
    // Ignore if node doesn't exist
    //当前节点为空就退出
    if (node == null)
        return;

    //异常退出将节点线程引用置空
    node.thread = null;

    // Skip cancelled predecessors
    //取到该节点的上个节点的等待状态小于等于0
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    // predNext is the apparent node to unsplice. CASes below will
    // fail if not, in which case, we lost race vs another cancel
    // or signal, so no further action is necessary.
    Node predNext = pred.next;

    // Can use unconditional write instead of CAS here.
    // After this atomic step, other Nodes can skip past us.
    // Before, we are free of interference from other threads.
    //当前节点的等待状态设置为1(取消状态)
    node.waitStatus = Node.CANCELLED;

    // If we are the tail, remove ourselves.
    将当前节点是否和尾节点相等,相等则将尾节点设置为当前节点的上个节点,上个节点的下一个节点设置为空
    if (node == tail && compareAndSetTail(node, pred)) {
        compareAndSetNext(pred, predNext, null);
    } else {
        // If successor needs signal, try to set pred's next-link
        // so it will get one. Otherwise wake it up to propagate.
        int ws;
        前节点不等于头节点并且前节点等待状态不为-1或者将前节点的等待状态设置为-1成功并且前节点的线程属性不为空,当前节点的下一个节点不为空且等待状态小于等于0,CAS设置前节点的下一个节点为当前节点的下一个节点
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
            //否则唤醒一个节点的线程
            unparkSuccessor(node);
        }

        node.next = node; // help GC
    }
}

方法十五:
private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    //获取获取当前节点的等待状态
    int ws = node.waitStatus;
    //小于0则进行CAS状态设置为0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    Node s = node.next;
    //当前节点的下一个节点如果为空,或者下一个等待状态大于0,s设置为null,
    if (s == null || s.waitStatus > 0) {
        s = null;
        //从尾节点开始便利到当前节点,取最靠近当前节点的且等待状态小于等于0的赋值给s
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    //如果s不为空,则唤醒该节点的线程方法
    if (s != null)
        LockSupport.unpark(s.thread);
}

方法十六:
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        //尾节点是否为空,为空则通过CAS设置头节点,并将头节点设置给尾节点,再次循环
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //不为空则将当前节点的上一个节点引用设置为尾节点,通过cas方式将尾节点设置为当前节点,原尾节点的下一个节点设置为当前节点,并返回上一个节点
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

总结

ReentrantLock通过CAS保证原子操作,通过AQS将阻塞线程放置在队列中等待,从头取节点线程,放置进来的线程节点在对尾.