锁优化的建议

1、减小锁持有时间

它的核心思想就是不要在不必需要的代码上加锁，因为线程持有的锁时间过长，相对地，锁的竞争程度也就越激烈。

看下面的代码：

public synchronized void syncMethod() {
        othercode1();
        mutextMethod();
        othercode2();
    }

    public void syncMethod() {
        othercode1();
        synchronized (this) {
            mutextMethod();
        }
        othercode2();
    }

2、减小锁锁粒度

减小锁粒度也是一种削弱多线程锁竞争的有效手段。典型的使用场景就是ConcurrentHashMap。

对于HashMap来说，最重要的两个方法就是get和put方法。一种最自然的想法就是对整个HashMap加锁，必然可以得到一个线程安全的对象。但是这样做，加锁的粒度太大，对于ConcurrentHashMap，它内部进一步细分了若干个小的HashMap，称之为段 segment。默认情况下ConcurrentHashMap，被进一步细分为16个段。

如果需要在ConcurentHashMap中增加一个新的表项，并不是将整个HashMap加锁，而是首先根据hashcode得到该表项应该被存放到那个段中，然后对该段加锁，并完成put操作。在多线程环境中，如果多个线程同时进行put操作，只要被加入的表项不存放在同一个段中，则线程间便可以做到真正的并行。

@SuppressWarnings("unchecked")
    public V put(K key, V value) {
        Segment<K,V> s;
        if (value == null)
            throw new NullPointerException();
        int hash = hash(key);
        int j = (hash >>> segmentShift) & segmentMask;
        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
            s = ensureSegment(j);
        return s.put(key, hash, value, false);
    }

3、 读写分离锁来替换独占锁

使用读写锁ReadWriteLock可以提供系统的性能。

4、 锁分离

如果将读写锁的思想做进一步的延伸，就是锁分离。典型的案例就是LinkedBlockingQueue的实现。

如果使用独占锁，则要求在两个操作进行时，获取当前队列的独占锁，那么take和put操作就不可能真正的并发，在运行时，它们会彼此等待对方释放锁资源。在这种情况下，锁竞争会相对比较激烈，从而影响程序在高并发的性能。

因此在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();

    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition();
/** Current number of elements */
    private final AtomicInteger count = new AtomicInteger(0);

下面来看下take的源码：

 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();
            }
            x = dequeue(); // 获取一个元素  
            c = count.getAndDecrement();//元素的数量减一
            if (c > 1)
                notEmpty.signal();// 大于1，唤醒其他线程进行take操作。
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

下面看 put的源码

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);
        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.
             */
            while (count.get() == capacity) {// 队列已经满了
                notFull.await();
            }
            enqueue(node); // 存放一个元素
            c = count.getAndIncrement();//数量加一
            if (c + 1 < capacity)// 还有空间，唤醒其他的线程进行put操作。
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }

、

5 、锁粗化

虚拟机在遇到一连串连续地对同一锁不断进行请求和释放的操作时，便会把所有的锁操作整合成对锁的一次请求，从而减少对锁的请求同步次数，这个操作叫做锁的粗化。

看下面的代码就清楚了

public void syncMethod() {

        synchronized (this) {
            mutextMethod2();
        }
        synchronized (this) {
            mutextMethod2();
        }

    }

public void syncMethod() {

        synchronized (this) {
            mutextMethod1();
            mutextMethod2();
        }


    }