关于java:Lock介绍

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将阻塞线程搁置在队列中期待,从头取节点线程,搁置进来的线程节点在对尾.