实战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 node = new Node(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){        //此时把锁放到循环外边去最好
        //...
    }
}

锁偏向

轻量级锁

自旋锁

锁消除

锁偏向

原理:一个线程获得锁,则进入偏向模式,当这个线程再次请求锁时,无需再做任何同步操作
场景:几乎没有锁竞争的场合
操作:竞争激烈时建议关闭. -XX:+UseBiasedLocking可以开启偏向锁

轻量级锁

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

自旋锁

原理:锁膨胀后,尝试自旋,若干次后若仍得不到锁,转入重量级锁,将线程挂起
场景:竞争不激烈,且持有锁时间较短

锁消除

原理:去除不可能存在共享的资源竞争锁,如某些jdk内部自带的类
场景:单线程下的加锁操作会被锁消除
逃逸分析:观察某变量是否会逃逸出某个作用域,如果该变量没有逃逸出该作用域,则虚拟机会把该变量内部的锁消除掉
操作:-XX:+DoEscapeAnalysis 打开逃逸分析; -XX:+EliminateLocks 打开锁消除