当前位置:首页 > 开发 > 编程语言 > Java > 正文

Java 锁分离

发表于: 2014-10-16   作者:annan211   来源:转载   浏览:
摘要:     读写锁思想的延伸就是锁分离。读写锁根据读写操作功能上的不同,进行了有效的锁分离。依据应用程序的功能特点,使用类似的分离思想,也可以对独占锁进行分离。 一个典型的应用就是java.util.concurrent.LinkedBlockingQueue.     在LinkedBlockingQueue的实现中。take()和

    读写锁思想的延伸就是锁分离。读写锁根据读写操作功能上的不同,进行了有效的锁分离。依据应用程序的功能特点,使用类似的分离思想,也可以对独占锁进行分离。
一个典型的应用就是java.util.concurrent.LinkedBlockingQueue.

    在LinkedBlockingQueue的实现中。take()和put()函数分别实现了从队列中获取数据和往队列中增加数据的功能。虽然这两个操作都是对当前队列进行修改操作,但由于LinkedBlockingQueue 是基于链表实现的,因此这两个操作分别对应这链表的前端和尾端,从理论上讲,这两个操作并不冲突。

   如果使用独占锁,则要求在这两个操作进行时获取独占锁,那么这两个操作就不可能实现真正意义上的并发,激烈的锁竞争从而 影响系统性能。
 
   在jdk中,并没有使用这种方式,取而代之的是 两把不同的锁分离了take()和put()操作。



  
      /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock(); 
   


 
    以上代码定义了 takeLock 和 putLock ,他们分别对应着 take() 和 put()操作,take()和put()是相互独立的,take(0和take()竞争锁,put()和put()竞争锁。
 


 
       public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();// 不允许同时读取锁
        try {
            try {
                while (count.get() == 0)
                    notEmpty.await();
            } catch (InterruptedException ie) {
                notEmpty.signal(); // propagate to a non-interrupted thread
                throw ie;
            }

            x = extract();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }
   


  
public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        // Note: convention in all put/take/etc is to preset
        // local var holding count  negative to indicate failure unless set.
        int c = -1;
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();//不允许同时修改锁
        try {
            /*
             * Note that count is used in wait guard even though it is
             * not protected by lock. This works because count can
             * only decrease at this point (all other puts are shut
             * out by lock), and we (or some other waiting put) are
             * signalled if it ever changes from
             * capacity. Similarly for all other uses of count in
             * other wait guards.
             */
            try {
                while (count.get() == capacity)
                    notFull.await();
            } catch (InterruptedException ie) {
                notFull.signal(); // propagate to a non-interrupted thread
                throw ie;
            }
            insert(e);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }




  概念太多反而不易于理解,这里简单说下 锁分离和分段锁。
  我们以ConcurrentHashMap 这种数据结构来分析,锁分离机制,就是把一个HashMap 分成很多个segement,对每一个segement的写操作上锁。他的get()操作是没有锁的,具体思想就是把每个hash槽中的链表的头节点置成final的。对hash槽中链表操作,只能从头部去处理。这样就不会有读不一致的情况出现。这个原理,最好还是看源码,比较清晰。

Java 锁分离

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号