锁优化

减少锁持有时间

只用在有线程安全要求的程序上加锁

减小锁粒度

将大对象（这个对象可能会被很多线程访问），拆成小对象，大大增加并行度，降低锁竞争。降低了锁的竞争，偏向锁，轻量级锁成功率才会提高。最最典型的减小锁粒度的案例就是 ConcurrentHashMap。

锁分离

最常见的锁分离就是读写锁 ReadWriteLock，根据功能进行分离成读锁和写锁，这样读读不互斥，读写互斥，写写互斥，即保证了线程安全，又提高了性能。读写分离思想可以延伸，只要操作互不影响，锁就可以分离。比如 LinkedBlockingQueue 从头部取出，从尾部放数据

锁消除

锁消除是在编译器级别的事情。在即时编译器时，如果发现不可能被共享的对象，则可以消除这些对象的锁操作，多数是因为程序员编码不规范引起。

比如下面的代码，StringBuffer 是线程安全的，append 方法使用 synchronized 修饰是同步方法，每次只能有一个线程操作。但是 sb 这个局部变量只会在 add 方法中使用，并没有被 return 出去，所以 sb 是不可能被共享的资源，在调用 add 方法时，JVM 会自动消除内部的锁。

public class StringBufferWithoutSync {
    public void add(String str1, String str2) {
    	// StringBuffer是线程安全，由于sb只会在append方法中使用，不可能被其他线程引用
    	// 因此sb属于不可能共享的资源，JVM会自动消除内部的锁
        StringBuffer sb = new StringBuffer();
        sb.append(str1).append(str2);
    }

    public static void main(String[] args) {
        StringBufferWithoutSync withoutSync = new StringBufferWithoutSync();
        for (int i = 0; i < 1000; i++) {
            withoutSync.add("aaa", "bbb");
        }
    }
}

锁粗化

通常情况下，为了保证多线程间的有效并发，会要求每个线程持有锁的时间尽量短，即在使用完公共资源后，应该立即释放锁。但是，凡事都有一个度，如果对同一个锁不停的进行请求、同步和释放，其本身也会消耗系统宝贵的资源，反而不利于性能的优化 。

例如下面这段代码，因为 append 方法时同步方法，每次调用时都会进行 100 次的锁操作，极大降低了性能，因此 JVM 会优化扩大锁的范围，每次只进行一次锁操作，循环 100 次后再释放锁。

public class CoarseSync {
	public static String copyString100Times(String target) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 100; i++) {
            sb.append(target);
        }
        return sb.toString();
    }
}