Java中的显示锁ReentrantLock使用与原理

原文链接:https://juejin.im/post/5bf18909f265da611036a4f0

考虑一个场景,轮流打印0-100以内的技术和偶数。通过使用 synchronize 的 wait,notify机制就可以实现,核心思路如下:
使用两个线程,一个打印奇数,一个打印偶数。这两个线程会共享一个数据,数据每次自增,当打印奇数的线程发现当前要打印的数字不是奇数时,执行等待,否则打印奇数,并将数字自增1,对于打印偶数的线程也是如此

//打印奇数的线程
private static class OldRunner implements Runnable{
    private MyNumber n;

    public OldRunner(MyNumber n) {
        this.n = n;
    }

    public void run() {
        while (true){
            n.waitToOld();  //等待数据变成奇数
            System.out.println("old:" + n.getVal());
            n.increase();
            if (n.getVal()>98){
                break;
            }
        }
    }
}
//打印偶数的线程
private static class EvenRunner implements Runnable{
    private MyNumber n;

    public EvenRunner(MyNumber n) {
        this.n = n;
    }

    public void run() {
        while (true){
            n.waitToEven();            //等待数据变成偶数
            System.out.println("even:"+n.getVal());
            n.increase(); 
            if (n.getVal()>99){
                break;
            }
        }
    }
}
复制代码

共享的数据如下

private static class MyNumber{
    private int val;

    public MyNumber(int val) {
        this.val = val;
    }

    public int getVal() {
        return val;
    }
    public synchronized void increase(){
        val++;
        notify(); //数据变了,唤醒另外的线程
    }
    public synchronized void  waitToOld(){
        while ((val % 2)==0){
            try {
                System.out.println("i am "+Thread.currentThread().getName()+" ,but now is even:"+val+",so wait");
                wait(); //只要是偶数,一直等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized void waitToEven(){
        while ((val % 2)!=0){
            try {
                System.out.println("i am "+Thread.currentThread().getName()+"  ,but now old:"+val+",so wait");
                wait(); //只要是奇数,一直等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
复制代码

运行代码如下

MyNumber n = new MyNumber(0);
Thread old=new Thread(new OldRunner(n),"old-thread");
Thread even = new Thread(new EvenRunner(n),"even-thread");
old.start();
even.start();
复制代码

运行结果如下

i am old-thread ,but now is even:0,so wait
even:0
i am even-thread  ,but now old:1,so wait
old:1
i am old-thread ,but now is even:2,so wait
even:2
i am even-thread  ,but now old:3,so wait
old:3
i am old-thread ,but now is even:4,so wait
even:4
i am even-thread  ,but now old:5,so wait
old:5
i am old-thread ,but now is even:6,so wait
even:6
i am even-thread  ,but now old:7,so wait
old:7
i am old-thread ,but now is even:8,so wait
even:8
复制代码

上述方法使用的是 synchronize的 wait notify机制,同样可以使用显示锁来实现,两个打印的线程还是同一个线程,只是使用的是显示锁来控制等待事件

private static class MyNumber{
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private int val;

    public MyNumber(int val) {
        this.val = val;
    }

    public int getVal() {
        return val;
    }
    public  void increase(){
        lock.lock();
        try {
            val++;
            condition.signalAll(); //通知线程
        }finally {
            lock.unlock();
        }

    }
    public  void  waitToOld(){
        lock.lock();
        try{
            while ((val % 2)==0){
                try {
                    System.out.println("i am should print old ,but now is even:"+val+",so wait");
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }finally {
            lock.unlock();
        }
    }
    public void waitToEven(){
        lock.lock(); //显示的锁定
        try{
            while ((val % 2)!=0){
                try {
                    System.out.println("i am should print even ,but now old:"+val+",so wait");
                    condition.await();//执行等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }finally {
            lock.unlock(); //显示的释放
        }

    }
}
复制代码

同样可以得到上述的效果

显示锁的功能

显示锁在java中通过接口Lock提供如下功能

  • lock: 线程无法获取锁会进入休眠状态,直到获取成功
  • lockInterruptibly: 如果获取成功,立即返回,否则一直休眠到线程被中断或者是获取成功
  • tryLock:不会造成线程休眠,方法执行会立即返回,获取到了锁,返回true,否则返回false
  • tryLock(long time, TimeUnit unit) throws InterruptedException : 在等待时间内没有发生过中断,并且没有获取锁,就一直等待,当获取到了,或者是线程中断了,或者是超时时间到了这三者发生一个就返回,并记录是否有获取到锁
  • unlock:释放锁
  • newCondition:每次调用创建一个锁的等待条件,也就是说一个锁可以拥有多个条件

Condition的功能

接口Condition把Object的监视器方法wait和notify分离出来,使得一个对象可以有多个等待的条件来执行等待,配合Lock的newCondition来实现。

  • await:使当前线程休眠,不可调度。这四种情况下会恢复 1:其它线程调用了signal,当前线程恰好被选中了恢复执行;2: 其它线程调用了signalAll;3:其它线程中断了当前线程 4:spurious wakeup (假醒)。无论什么情况,在await方法返回之前,当前线程必须重新获取锁
  • awaitUninterruptibly:使当前线程休眠,不可调度。这三种情况下会恢复 1:其它线程调用了signal,当前线程恰好被选中了恢复执行;2: 其它线程调用了signalAll;3:spurious wakeup (假醒)。
  • awaitNanos:使当前线程休眠,不可调度。这四种情况下会恢复 1:其它线程调用了signal,当前线程恰好被选中了恢复执行;2: 其它线程调用了signalAll;3:其它线程中断了当前线程 4:spurious wakeup (假醒)。5:超时了
  • await(long time, TimeUnit unit) :与awaitNanos类似,只是换了个时间单位
  • awaitUntil(Date deadline):与awaitNanos相似,只是指定日期之后返回,而不是指定的一段时间
  • signal:唤醒一个等待的线程
  • signalAll:唤醒所有等待的线程

ReentrantLock

从源码中可以看到,ReentrantLock的所有实现全都依赖于内部类Sync和ConditionObject。
Sync本身是个抽象类,负责手动lock和unlock,ConditionObject则实现在父类AbstractOwnableSynchronizer中,负责await与signal Sync的继承结构如下

Sync的两个实现类,公平锁和非公平锁

公平的锁会把权限给等待时间最长的线程来执行,非公平则获取执行权限的线程与线程本身的等待时间无关

默认初始化ReentrantLock使用的是非公平锁,当然可以通过指定参数来使用公平锁

public ReentrantLock() {
   sync = new NonfairSync();
}
复制代码

当执行获取锁时,实际就是去执行 Sync 的lock操作:

public void lock() {
    sync.lock();
}
复制代码

对应在不同的锁机制中有不同的实现

  1. 公平锁实现
    final void lock() {
        acquire(1);
    }
    复制代码
  2. 非公平锁实现
    final void lock() {
        if (compareAndSetState(0, 1)) //先看当前锁是不是已经被占有了,如果没有,就直接将当前线程设置为占有的线程
            setExclusiveOwnerThread(Thread.currentThread());
        else        
            acquire(1); //锁已经被占有的情况下,尝试获取
    }
    复制代码

二者都调用父类AbstractQueuedSynchronizer的方法

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //一旦抢失败,就会进入队列,进入队列后则是依据FIFO的原则来执行唤醒
        selfInterrupt();
}
复制代码

当执行unlock时,对应方法在父类AbstractQueuedSynchronizer中

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}
复制代码

公平锁和非公平锁则分别对获取锁的方式tryAcquire 做了实现,而tryRelease的实现机制则都是一样的

公平锁实现tryAcquire

源码如下

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState(); //获取当前的同步状态
    if (c == 0) {
        //等于0 表示没有被其它线程获取过锁
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            //hasQueuedPredecessors 判断在当前线程的前面是不是还有其它的线程,如果有,也就是锁sync上有一个等待的线程,那么它不能获取锁,这意味着,只有等待时间最长的线程能够获取锁,这就是是公平性的体现
            //compareAndSetState 看当前在内存中存储的值是不是真的是0,如果是0就设置成accquires的取值。对于JAVA,这种需要直接操作内存的操作是通过unsafe来完成,具体的实现机制则依赖于操作系统。
            //存储获取当前锁的线程
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        //判断是不是当前线程获取的锁
        int nextc = c + acquires;
        if (nextc < 0)//一个线程能够获取同一个锁的次数是有限制的,就是int的最大值
            throw new Error("Maximum lock count exceeded");
        setState(nextc); //在当前的基础上再增加一次锁被持有的次数
        return true;
    }
    //锁被其它线程持有,获取失败
    return false;
}
复制代码

非公平锁实现tryAcquire

获取的关键实现为nonfairTryAcquire,源码如下

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        //锁没有被持有
        //可以看到这里会无视sync queue中是否有其它线程,只要执行到了当前线程,就会去获取锁
        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;
}
复制代码

释放锁的机制

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread()) //只能是线程拥有这释放
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        //当占有次数为0的时候,就认为所有的锁都释放完毕了
        free = true; 
        setExclusiveOwnerThread(null);
    }
    setState(c); //更新锁的状态
    return free;
}
复制代码

从源码的实现可以看到

  • ReentrantLock获取锁时,在锁已经被占有的情况下,如果占有锁的线程是当前线程,那么允许重入,即再次占有,如果由其它线程占有,则获取失败,由此可见,ReetrantLock本身对锁的持有是可重入的,同时是线程独占的
  • 公平与非公平就体现在,当执行的线程去获取锁的时候,公平的会去看是否有等待时间比它更长的,而非公平的就优先直接去占有锁

ReentrantLock的tryLock()与tryLock(long timeout, TimeUnit unit):

public boolean tryLock() {
//本质上就是执行一次非公平的抢锁
   return sync.nonfairTryAcquire(1); 
}
复制代码

有时限的tryLock核心代码是 sync.tryAcquireNanos(1, unit.toNanos(timeout));,由于有超时时间,它会直接放到等待队列中,他与后面要讲的AQS的lock原理中acquireQueued的区别在于park的时间是有限的,详见源码 AbstractQueuedSynchronizer.doAcquireNanos

为什么需要显示锁

内置锁功能上有一定的局限性,它无法响应中断,不能设置等待的时间

展开阅读全文

ReentrantLock中tryLock的使用

05-19

请各位帮忙看看,以下是代码rn[code=java]rn static ReentrantLock lock = new ReentrantLock();rn rn public static void main(String[] args) rn ExecutorService es = Executors.newCachedThreadPool();rn rn es.execute(new Runnable() rn rn @Overridern public void run() rn foo("thread1");rn rn );rn rn es.execute(new Runnable() rn rn @Overridern public void run() rn foo("thread2");rn rn );rn rn rn private static void foo(String threadName) rn try rn lock.tryLock();rn System.out.println(lock.getHoldCount());rn System.out.println(threadName);rn try rn Thread.sleep(2000);rn catch (InterruptedException e) rn // TODO Auto-generated catch blockrn e.printStackTrace();rn rn finally rn lock.unlock();rn System.out.println(lock.getHoldCount());rn rn rn[/code]rn输出信息是:rn1rnthread1rn(此处无等待)rn0rnthread2rn0rnException in thread "pool-1-thread-2" java.lang.IllegalMonitorStateExceptionrn at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:155)rn at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1260)rn at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:460)rn at test.reentrantlock.Test.foo(Test.java:43)rn at test.reentrantlock.Test.access$0(Test.java:31)rn at test.reentrantlock.Test$2.run(Test.java:26)rn at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110)rn at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)rn at java.lang.Thread.run(Thread.java:722)rnrn为什么线程2会立刻获得锁,而且获得锁之后的HoldCount是0,最后抛出的异常是因为线程1准备释放锁时,它已经不是锁持有者了。 论坛

没有更多推荐了,返回首页