当前位置:首页 > 开发 > 编程语言 > 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

    震惊

    震惊

编辑推荐
concurrenthashmap是一个非常好的map实现,在高并发操作的场景下会有非常好的效率。实现的目的主要
concurrenthashmap是一个非常好的map实现,在高并发操作的场景下会有非常好的效率。实现的目的主要
ReaderWriterLockSlim 类 表示用于管理资源访问的锁定状态,可实现多线程读取或进行独占式写入访问
在了解轻量级锁之前,首先要知道什么是CAS CAS--Compare And Swap 比较并交换--通过比较传入的旧值
多线程应用中,我们往往会对同一对象或类进行操作,这时我们需要应用同步锁,以保证程序的正常运行
概述 假如行为不同步在多线程环境下就会出现混乱。 在共享内存环境中读取一块由可能被多个线程更新的
1:在javaN(new)IO 中提供了文件锁的功能, 这样当一个线程文件锁定后, 其他的线程是无法操作此文件
Java中的锁 锁像synchronized同步块一样,是一种线程同步机制,但比Java中的synchronized同步块更复
synchronized,称为内部锁或监视器。 当线程释放锁时,JMM会把该线程对应的本地内存中的共享变量刷
如果你在大学学习过操作系统,你可能还记得监听器在操作系统中是很重要的概念。同样监听器在java同
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号