[java多线程]-显示锁的实现

概述

通过这节的学习,可以明白显示锁的实现,以及可以创建自己的锁。
我们常见的显示锁,以及其他的锁工具有ReentrantLockCountDownLatchSemaphore。它们有一些共同的特点就是状态控制,而对于状态的控制,它们都使用了AQS(AbstractQueuedSynchronizer)实现。

AQS

如果一个类想实现状态依赖,可以使用AQS实现。AQS负责管理同步器类中状态,它管理着一个整数状态信息,可以通过getStatesetState以及compareAndSetStateprotected方法来进行操作。这个整数可以表示任意状态,比如CountDownLatch表示计数,Semaphore表示剩余的许可数量等等。

如果某个同步器支持支持独占的获取操作,那么需要实现一些保护方法,包括tryAcquiretryReleaseisHeldExclusively。而支持共享的同步器,则实现 tryAcquireSharedtryReleaseShared等方法。AQS中的acquireacquireSharedreleasereleaseShared等方法使用模板方法模式来组织,都将会分别调用子类中的tryAcquiretryAcquireSharedtryReleasetryReleaseShared

部分摘录自《java并发编程实战》

后面有时间再进一步分析AQS的实现。

CountDownLatch

CountDownLatch作为计数的闭锁,也是通过AQS实现。基本结构如下:

CountDownLatch依赖Sync,而Sync继承自AQS。后面我们来一起分析一下源码。

Sync的实现

首先我们先来分析CountDownLatch的内部类Sync,我们将一个个函数分析。

private static final class Sync extends AbstractQueuedSynchronizer {
        Sync(int count) {
            setState(count);
        }
    }

Sync继承自AQS,构造函数中是通过setState设置状态即最大的许可数量。

private static final class Sync extends AbstractQueuedSynchronizer {
        ......
        int getCount() {
            return getState();
        }
    }

getCount()返回当前剩余的许可数量。

private static final class Sync extends AbstractQueuedSynchronizer {
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
    }

看到tryAcquireShared蒙圈了,What?SXXX!前面我们说过AQSacquireShared方法将调用子类tryAcquireShared,那就需要看看AQSacquireShared的方法了。

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

原来如此!acquireShared方法中,原来tryAcquireShared(arg) < 0,才会继续执行,所以SynctryAcquireShared才会那样写,状态等于0,直接返回1,否则返回-1。

继续分析SynctryReleaseShared

private static final class Sync extends AbstractQueuedSynchronizer {
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c - 1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

先是获取当前的状态值(剩余的计数),等于0没有了剩余的计数直接返回false。不满足接着使用compareAndSetState更新状态,我的更新就更新了,为啥子还有个for死循环呢?我们看看compareAndSetState怎么实现的。

protected final boolean compareAndSetState(int expect, int update) {
    return U.compareAndSwapInt(this, STATE, expect, update);
}

原来是使用CAS,CAS是比较并交换,示意图有点类似下图,是现代处理器对并发的支持。详细内容请Google。

说完CAS计数,回到我们的tryReleaseShared方法,添加死循环是重试逻辑,无法更新,继续重试。到此我们对Sync已经分析完成。

CountDownLatch的实现

CountDownLatch的实现全仰仗Sync。我们分析的时候只分析关键的接口

await方法
public class CountDownLatch {
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
    ......
}

await方法调用了直接调用了acquireSharedInterruptibly方法。ASQ已经实现此方法。

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

首先检测线程的状态,然后通过tryAcquireShared(arg)是否进入等待队列( doAcquireSharedInterruptibly(arg)进入等待,我们不做进一步的分析)。我们Sync实现的是

protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

因此当没有剩余的许可数,也就是CountDownLatch接入了结束态,直接await就不等待了。而当还有剩余的许可数时,就会进入等待。

countDown方法
public class CountDownLatch {
    ......
    public void countDown() {
        sync.releaseShared(1);
    }
    ......
}

直接调用了releaseShared方法了。

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        //唤醒线程
        doReleaseShared();
        return true;
    }
    return false;
}

Sync实现了tryReleaseShared

private static final class Sync extends AbstractQueuedSynchronizer {
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c - 1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

只用当nextc等于0的时候才会返回true,也就是没有了许可数了,此时就会唤醒线程。

总结

从上面的分析,我们可以得出,在await中会Sync根据tryAcquireShared进行判断要不要进入等待状态,而countDown中会调用SynctryReleaseShared的来递减许可书,直到许可数为0,通知等待的线程。

ReentrantLock

ReentrantLock的基本结构。

NoFairSync

对于ReentrantLock,以NoFairSync来分析

如果某个同步器支持支持独占的获取操作,那么需要实现一些保护方法,包括tryAcquiretryReleaseisHeldExclusively

lock方法

public class ReentrantLock implements Lock, java.io.Serializable {
    private final Sync sync;
    public void lock() {
        sync.lock();
    }
}

对于ReentrantLockSynclock方法。

 static final class NonfairSync extends Sync {
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
    }

Synclock方法,首先会通过compareAndSetState来更新状态,更新成功,设置当前拥有锁的线程。没有更新成功说明锁已经被其他线程更新了,调用acquire(1),前面说过acquire会调用tryAcquire方法。

 static final class NonfairSync extends Sync {
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

直接调用父类的nonfairTryAcquire方法。

abstract static class Sync extends AbstractQueuedSynchronizer {
        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;
        }
}

传递的acquires为1,首先获取状态,再次尝试更新状态。无法更新状态时候,判断当前的线程是否为拥有锁的线程,是就更新状态,这个是重入,记录当前获取锁的次数。

总结:从上面可知,锁的状态有两种,一种是0表示没有线程持有,一种大于等于1表示锁已经被持有。并且通过setState更新重入次数。

unLock方法

public class ReentrantLock implements Lock, java.io.Serializable {
    public void unlock() {
        sync.release(1);
    }
}

直接调用NonfairSyncrelease方法。而我们知道release方法会调用到tryRelease。会调用到NonfairSync直接使用父类SynctryRelease方法。

    abstract static class Sync extends AbstractQueuedSynchronizer {
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }
    }

Sync当前的状态减去releases,这是因为我们一步步去减少重入。然后判断当前线程和用于锁的线程是不是同一个线程,不是同一线程抛出异常,这就是为什么获取的锁和释放锁需要在同一线程,不然就等着报错吧。当状态为0了,就说明锁没被持有,设置当前拥有锁的线程为null。

实现自己的独占锁

实现互斥锁,需要复写AbstractQueuedSynchronizertryAcquiretryRelease方法。我们假设有两种状态,0表示未被持有,1表示已经被持有。

public class MyLock {
    private Sync mSync;
    public MyLock(Sync sync) {
        mSync = sync;
    }
    private class Sync extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int arg) {
            int state = getState();
            if (state == 0) {
                if (compareAndSetState(0, 1)) {
                    return true;
                }
            }
            return false;
        }
        @Override
        protected boolean tryRelease(int arg) {
            int state = getState();
            if (state == 1) {
                if (compareAndSetState(1, 0)) {
                    return true;
                }
            }
            return false;
        }
    }
    public void lock(){
        mSync.acquire(1);
    }
    public void unLock(){
        mSync.release(1);
    }
}

可能这个类只是演示,它不够完善,比如超时等待,InterruptedException响应的lock等等,但是原理已经有了。
对于状态控制的类,我们可以使用AQS实现自己的类。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值