转载

实战java高并发程序设计第四章-锁优化

锁的使用建议

减少锁持有时间
减少锁粒度
读写锁替代独占锁
锁分离
锁粗化

减少锁的持有时间
减少锁的持有时间有助于降低冲突的可能性,进而提升并发能力
减少锁粒度
例如ConcurrentHashMap,内部分为16个segment,加锁时不会像hashmap一样全局加锁,只需要对相应segment加锁,但是如果需要获取全局的信息,比如size(),首先会使用无锁的方法进行求值,如果失败将要获取所有segment的锁
读写锁替代独占锁(ReadWriteLock)
读多写少的场景下使用读写锁可以显著提高系统的并发能力
锁分离
在读写锁的前提上再进行升级,对独占锁进行分离,如LinkedBlockingQueue,由于是基于链表结构,take()和put()分别作用于队列的前端和尾端.两者并不冲突,故可以使用takeLock和putLock,从而削弱锁竞争的可能性

public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();        //take锁加锁
        try {
            while (count.get() == 0) {
                notEmpty.await();        //如果无可用数据则一直等待,知道put()方法的通知
            }
            x = dequeue();
            c = count.getAndDecrement();    //原子操作-1
            if (c > 1)
                notEmpty.signal();       //通知其他take方法
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();            //通知put方法 已有空间
        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;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            while (count.get() == capacity) {
                notFull.await();
            }
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }

锁粗化

一连串对同一个锁不停地进行请求和释放会被整合成对锁的一次操作,从而减少对锁请求同步次数

for(int i=0;i<100;i++){
    synchronized(lock){        //此时把锁放到循环外边去最好
        //...
    }
}

JVM对锁的优化

锁偏向
轻量级锁
自旋锁
锁消除

锁偏向

原理:一个线程获得锁,则进入偏向模式,当这个线程再次请求锁时,无需再做任何同步操作

场景:几乎没有锁竞争的场合

操作:竞争激烈时建议关闭. -XX:+UseBiasedLocking可以开启偏向锁

轻量级锁

原理:偏向锁失败后,会膨胀为轻量级锁,对象头部会尝试指向持有锁的线程堆栈内部,来判断是否持有对象锁,如果获得轻量级锁成功,则进入临界区,否则表示其他线程抢占到锁,当前线程膨胀为重量级锁(在膨胀前可以自旋再去尝试获得)

场景:不存在锁竞争或竞争不激烈

自旋锁

原理:锁膨胀后,尝试自旋,若干次后若仍得不到锁,转入重量级锁,将线程挂起

场景:竞争不激烈,且持有锁时间较短

锁消除

原理:去除不可能存在共享的资源竞争锁,如某些jdk内部自带的类

场景:单线程下的加锁操作会被锁消除

逃逸分析:观察某变量是否会逃逸出某个作用域,如果该变量没有逃逸出该作用域,则虚拟机会把该变量内部的锁消除掉

操作:-XX:+DoEscapeAnalysis 打开逃逸分析; -XX:+EliminateLocks 打开锁消除

ThreadLocal

无锁操作

死锁

原文 https://segmentfault.com/a/1190000020080334

正文到此结束

所属分类： Java 编程技术

本文标签： map queue 并发 cat http synchronized 线程同步 JVM final ConcurrentHashMap https 锁 HashMap mina 空间 id db 时间 IO node 数据 Atom
版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
本文海报： 生成海报一生成海报二

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

实战java高并发程序设计第四章-锁优化

锁的使用建议

JVM对锁的优化

ThreadLocal

无锁操作

死锁

热门推荐

相关文章

说给你听

本文目录

随机标签

书籍教程

近期评论

网站信息

其他链接

关于本站

问题交流