认识达内从这里开始

认真做教育专心促就业

Java 编程之美：并发编程高级篇（下）

发布：达内科技
来源：互联网
时间：2018-07-03 14:52

    3.2 获取锁-达内科技负责整理这次一定要好好看！
    void lock()当一个线程调用该方法,说明该线程希望获取该锁,如果锁当前没有被其它线程占用并且当前线程之前没有获取该锁,则当前线程会获取到该锁,然后设置当前锁的拥有者为当前线程,并设置 AQS 的状态值为 1 后直接返回.
    如果当前线程之前已经获取过该锁,则这次只是简单的把 AQS 的状态值 status 加 1 后返回.
    如果该锁已经被其它线程持有,则调用该方法的线程会被放入 AQS 队列后阻塞挂起.
    public void lock() { sync.lock(); }
    如上代码 ReentrantLock 的 lock() 是委托给了 sync 类,根据创建 ReentrantLock 时候构造函数选择 sync 的实现是 NonfairSync 或者 FairSync,这里先看 sync 的子类 NonfairSync 的情况,也就是非公平锁的时候:
    final void lock() { //(1)CAS设置状态值 if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else //(2)调用AQS的acquire方法 acquire(1); }
    如上代码(1)因为默认 AQS 的状态值为 0,所以第一个调用 Lock 的线程会通过 CAS 设置状态值为 1,CAS 成功则表示当前线程获取到了锁,然后 setExclusiveOwnerThread 设置了该锁持有者是当前线程.
    如果这时候有其它线程调用 lock 方法企图获取该锁执行代码(1)CAS 会失败,然后会调用 AQS 的 acquire 方法,这里注意传递参数为 1,这里在贴下 AQS 的 acquire 骨干代码:
    public final void acquire(int arg) { //(3)调用ReentrantLock重写的tryAcquire方法 if (!tryAcquire(arg) && // tryAcquiref返回false会把当前线程放入AQS阻塞队列 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
    之前说过 AQS 并没有提供可用的 tryAcquire 方法,tryAcquire 方法需要子类自己定制化,所以这里代码(3)会调用 ReentrantLock 重写的 tryAcquire 方法代码,这里先看下非公平锁的代码如下:
    protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); //(4)当前AQS状态值为0 if (c == 0) { if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } }//(5)当前线程是该锁持有者 else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; }//(6) return false; }
    如上代码(4)会看当前锁的状态值是否为 0,为 0 则说明当前该锁空闲,那么就尝试 CAS 获取该锁(尝试将 AQS 的状态值从 0 设置为 1),并设置当前锁的持有者为当前线程返回返回 true.
    如果当前状态值不为 0 则说明该锁已经被某个线程持有,所以代码(5)看当前线程是否是该锁的持有者,如果当前线程是该锁持有者,状态值增加 1 然后返回 true.
    如果当前线程不是锁的持有者则返回 false, 然后会被放入 AQS 阻塞队列.
    这里介绍完了非公平锁的实现代码,回过头来看看非公平在这里是怎么体现的,首先非公平是说先尝试获取锁的线程并不一定比后尝试获取锁的线程优先获取锁.
    这里假设线程 A 调用 lock()方法时候执行到了 nonfairTryAcquire 的代码(4)发现当前状态值不为 0,所以执行代码(5)发现当前线程不是线程持有者,则执行代码(6)返回 false,然后当前线程会被放入了 AQS 阻塞队列.
    这时候线程 B 也调用了 lock() 方法执行到 nonfairTryAcquire 的代码(4)时候发现当前状态值为 0 了(假设占有该锁的其它线程释放了该锁)所以通过 CAS 设置获取到了该锁.

而明明是线程 A 先请求获取的该锁那,这就是非公平锁的实现,这里线程 B 在获取锁前并没有看当前 AQS 队列里面是否有比自己请求该锁更早的线程,而是使用了抢夺策略.

达内科技

    那么下面看看公平锁是怎么实现公平的,公平锁的话只需要看 FairSync 重写的 tryAcquire 方法
    protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); //(7)当前AQS状态值为0 if (c == 0) { //(8)公平性策略 if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } //(9)当前线程是该锁持有者 else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; }//(10) return false; } }
    如上代码公平性的 tryAcquire 策略与非公平的类似,不同在于代码(8)处在设置 CAS 前添加了 hasQueuedPredecessors 方法,该方法是实现公平性的核心代码,代码如下:
    public final boolean hasQueuedPredecessors() { Node t = tail; // Read fields in reverse initialization order Node h = head; Node s; return h != t && ((s = h.next) == null || s.thread != Thread.currentThread()); }
    如上代码如果当前线程节点有前驱节点则返回 true,否者如果当前 AQS 队列为空或者当前线程节点是 AQS 的第一个节点则返回 false.
    其中如果 h==t 则说明当前队列为空则直接返回 false,如果 h!=t 并且 s==null 说明有一个元素将要作为 AQS 的第一个节点入队列,那么返回 true, 如果 h!=t 并且 s!=null 并且 s.thread != Thread.currentThread() 则说明队列里面的第一个元素不是当前线程则返回 true.
    void lockInterruptibly()
    与 lock() 方法类似,不同在于该方法对中断响应,就是当前线程在调用该方式时候,如果其它线程调用了当前线程线程的 interrupt()方法,当前线程会抛出 InterruptedException 异常然后返回
    public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1);}public final void acquireInterruptibly(int arg) throws InterruptedException { //当前线程被中断则直接抛出异常 if (Thread.interrupted()) throw new InterruptedException(); //尝试获取资源 if (!tryAcquire(arg)) //调用AQS可被状态的方法 doAcquireInterruptibly(arg);}
    boolean tryLock()
    达内科技的小编认为，尝试获取锁,如果当前该锁没有被其它线程持有则当前线程获取该锁并返回 true, 否者返回 false,注意该方法不会引起当前线程阻塞.
    public boolean tryLock() { return sync.nonfairTryAcquire(1);}final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); 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; }
    如上代码与非公平锁的 tryAcquire() 方法类似,所以 tryLock() 使用的是非公平策略.
    boolean tryLock(long timeout, TimeUnit unit)
    尝试获取锁与 tryLock()不同在于设置了超时时间,如果超时没有获取该锁则返回 false.
    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException { //调用AQS的tryAcquireNanos方法. return sync.tryAcquireNanos(1, unit.toNanos(timeout)); }
    3.3 释放锁
    void unlock()
    尝试释放锁,如果当前线程持有该锁,调用该方法会让该线程对该线程持有的 AQS 状态值减一,如果减去 1 后当前状态值为 0 则当前线程会释放对该锁的持有,否者仅仅减一而已.如果当前线程没有持有该锁调用了该方法则会抛出 IllegalMonitorStateException 异常 ,代码如下:
    public void unlock() { sync.release(1); } protected final boolean tryRelease(int releases) { //(11)如果不是锁持有者调用UNlock则抛出异常. int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; //(12)如果当前可重入次数为0,则清空锁持有线程 if (c == 0) { free = true; setExclusiveOwnerThread(null); } //(13)设置可重入次数为原始值-1 setState(c); return free; }
    如上代码(11)如果当前线程不是该锁持有者则直接抛出异常,否者看状态值剩余值是否为 0,为 0 则说明当前线程要释放对该锁的持有权,则执行(12)把当前锁持有者设置为 null.如果剩余值不为 0,则仅仅让当前线程对该锁的可重入次数减一.
    3.4 案例介绍
    下面使用 ReentrantLock 来实现一个简单的线程安全的 list:
    public static class ReentrantLockList { //线程不安全的list private ArrayList<String> array = new ArrayList<String>(); //独占锁 private volatile ReentrantLock lock = new ReentrantLock(); //添加元素 public void add(String e) { lock.lock(); try { array.add(e); } finally { lock.unlock(); } } //删元素 public void remove(String e) { lock.lock(); try { array.remove(e); } finally { lock.unlock(); } } //获取数据 public String get(int index) { lock.lock(); try { return array.get(index); } finally { lock.unlock(); } }
    如上代码通过在操作 array 元素前进行加锁保证同时只有一个线程可以对 array 数组进行修改,但是同时也只能有一个线程对 array 元素进行访问.
    四、读写锁 ReentrantReadWriteLock 原理
    在解决线程安全问题上使用 ReentrantLock 就可以,但是 ReentrantLock 是独占锁,同时只有一个线程可以获取该锁,而实际情况下会有写少读多的场景,显然 ReentrantLock 满足不了需求.
    所以 ReentrantReadWriteLock 应运而生,ReentrantReadWriteLock 采用读写分离,多个线程可以同时获取读锁.
    以上就是达内科技给大家做的内容详解,更多关于IT知识的学习,请继续关注达内科技

< 上一篇：Java 编程之美：并发编程高级篇（中）

下一篇：别做码农了，去做一名工程师-达内培训 >