深入学习java并发编程:ReentrantLock

原创 2016年05月30日 21:41:57
1、相关类图
  
2、ReentrantLock实现分析说明
        ReentrantLock重入锁能支持一个线程对资源重复的加锁,而不会把自己锁死。此外,还支持获取锁是的公平和非公平性选择。ReentrantLock
虽然没有像synchronized关键字一样支持隐式的重进入,但是调用lock()方,在已经获取到锁的情况下,能够再次调用lock()方法获取锁,而不被阻塞。
     1)实现可重入
      实现可重入需要解决两个问题:
        1 线程再次获取锁:锁需要识别获取所得线程是否是当前占据锁的线程,如果是,则再次获取到锁
        2锁的最终释放:线程重复n次获取锁,随后在第n次释放锁时,其他线程能够获取到锁。因此,锁的释放要求锁对于每次获取都进行计数自增,而在是释放时,计数自减,当计数减为0时,释放锁。在AQS里面有一个state字段,通过这个状态记录字段,记录锁获取的次数,它是一个volatile类型的整型值,因此对它的修改可以保证其他线程可以看到。
        ReentrantLock通过组合自定义同步器AQS实现锁的获取与释放,可以看到,针对公平锁与非公平锁,分别实现了FairSync和NonfairSync。
   构造器:
    public ReentrantLock() {   //默认是非公平锁
        sync = new NonfairSync();
    }
     public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
获取以及释放同步状态:   
          内部自定义AQS如下:   
  abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();
        /**
         * Performs non-fair tryLock.  tryAcquire is
         * implemented in subclasses, but both need nonfair
         * try for trylock method.
         */
        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;
        }
        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;
        }
        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
     }
           可以看到,在nonfairTryAcquire(int acquires)方法中添加了再次获取同步状态的处理逻辑:通过判断当前线程是否为获取锁的线程来决定获取操作是否成功,如果是获取锁的线程再次请求,则将同步状态值state进行增加并返回true,表示获取成功。
        tryRelease(int releases) 释放时,通过判断是否是当前线程,如果是,则减少同步状态值,当减为0是,就表示是最终释放,将占用线程设置为null,并设置free为true,返回。      
        NonfairSync 继承Sync :
static final class NonfairSync extends Sync { 
        private static final long serialVersionUID = 7316153563782823691L;
        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
   )
2)公平获取锁状态
       公平与否,是针对获取同步状态而言的,如果锁是公平的,那么锁的获取就应该按照请求的时间顺序,也就是FIFO。
  static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        final void lock() {
            acquire(1);
        }
        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }
         可以看到,公平的获取锁多了判断条件hasQueuedPredecessors()方法,及加入同步队列中当前节点是否有前驱节点的判断,如果该方法返回true,则表示有线程比当前线程更早的请求获取锁,因此需要等待前驱线程获取并释放锁之后才能继续获取锁。

3、ReentrantLock锁接口方法实现

   1)lock(): void 
  //方法中直接调用自定义同步器sync的lock()
    public void lock() {
        sync.lock();
    }

  2) lockInterruptibly(): void 
//调用自定义同步器sync的acquireInterruptibly模板方法
   public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
 3)unlock(): void
//调用自定义同步器sync的release模板方法
  public void unlock() {
        sync.release(1);
    }



并发编程学习总结(五) :java 显式锁ReentrantLock使用详解之条件对象(2)

(1) ReentrantLock的条件对象 通常,线程进入临界区,却发现在某一条件满足之后才能执行,条件对象就是用来管理那些已经获得了锁,但是却不能做有用工作的线程。 一个锁对象可以有一个或多个...

JAVA并发编程学习笔记之ReentrantLock—推荐-mark

ReentrantLock是一个可重入的互斥锁,ReentrantLock由最近成功获取锁,还没有释放的线程所拥有,当锁被另一个线程拥有时,调用lock的线程可以成功获取锁。如果锁已经被当前线程拥有,...

JAVA并发编程学习笔记之ReentrantLock

ReentrantLock是一个可重入的互斥锁,ReentrantLock由最近成功获取锁,还没有释放的线程所拥有,当锁被另一个线程拥有时,调用lock的线程可以成功获取锁。如果锁已经被当前线程拥有,...

JAVA并发编程学习笔记之ReentrantLock

ReentrantLock是一个可重入的互斥锁,ReentrantLock由最近成功获取锁,还没有释放的线程所拥有,当锁被另一个线程拥有时,调用lock的线程可以成功获取锁。如果锁已经被当前线程拥有,...

【Java】深入Java多线程和并发编程之ReentrantLock

http://hyxw5890.iteye.com/blog/1578597 ReentrantLock可以等同于synchronized使用、但是它比synchronized有更强的功能、...

【Java并发编程实战】-----“J.U.C”:ReentrantLock之三unlock方法分析

前篇博客LZ已经分析了ReentrantLock的lock()实现过程,我们了解到lock实现机制有公平锁和非公平锁,两者的主要区别在于公平锁要按照CLH队列等待获取锁,而非公平锁无视CLH队列直接获...
  • chenssy
  • chenssy
  • 2015年08月25日 08:10
  • 3101

【Java并发编程实战】—–“J.U.C”:ReentrantLock之二lock方法分析

前一篇博客简单介绍了ReentrantLock的定义和与synchronized的区别,下面跟随LZ的笔记来扒扒ReentrantLock的lock方法。我们知道ReentrantLock有公平锁、非...

《Java并发编程从入门到精通》显示锁Lock和ReentrantLock

显示锁Lock和ReentrantLock Lock是一个接口提供了无条件的、可轮询的、定时的、可中断的锁获取操作,所有加锁和解锁的方法都是显式的。包路径是:java.util.concurrent...

Java 并发编程之ReentrantLock和synchronized锁

前几天被问到ReentrantLock锁的用法和作用,竟然一时没答上来,太可惜了,ReentrantLock锁明明见了很多次,一直没留意。其实在前面分析UIL框架的时候,就有ReentrantLock...

JAVA并发编程--Semaphore、CountDownLatch、ReentrantLock、CyclicBarrier

Semaphore学习操作系统理论课的时候,教材上应该都会讲过信号量这种概念,java.util.concurrent.Semaphore类就是Java中这个概念的实现。比如资源R有5个实体,如果每个...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深入学习java并发编程:ReentrantLock
举报原因:
原因补充:

(最多只允许输入30个字)