锁优化有3个方向：

1.减少持有锁的时间：例如，将CPU密集和I/O密集的任务移到锁外，可以有效减少持有锁的时间，从而降低其他线程的阻塞时间。

2.减小加锁的粒度：将单个独占锁变为多个锁，从而将加锁请求均分到多个锁上，有效降低对锁的竞争。但是，增加锁的前提是多线程访问的变量间相互独立，如果多线程需要同时访问多个变量，则很难进行锁分解，因为要维持原子性。

3.放弃使用独占锁，使用非阻塞算法来保证并发安全。例如，使用并发容器、读写锁、不可变对象、原子变量、线程封闭等技术。

本文介绍减小锁粒度的方法：

public class ServerStatus { public final Set<String> users; public final Set<String> queries; public ServerStatus() { users = new HashSet<>(); queries = new HashSet<>(); } / * 独占锁意味着增加资源不能提升程序吞吐量，可伸缩性很差 * @param user */ public synchronized void addUser(String user) { users.add(user); } public synchronized void addQuery(String q) { queries.add(q); } public synchronized void removeUser(String user) { users.remove(user); } public synchronized void removeQuery(String query) { users.remove(query); } }

/ * 锁分解技术是减小了锁粒度，将锁住所有变量的全局锁变为锁住部分变量的局部锁。 * 锁分解能提升吞吐量的原理是将对一个锁的竞争均摊到2个锁上，从而降低了对单个锁的请求频率，有效地降低了竞争程度。 * 不足：与独占锁相比，锁分解技术在多处理器系统中只能将吞吐量提高一倍，可伸缩性还是受到限制。 */ public class ServerStatusLockDecompose { public final Set<String> users; public final Set<String> queries; public ServerStatusLockDecompose() { users = new HashSet<>(); queries = new HashSet<>(); } / * 独占锁意味着增加资源不能提升程序吞吐量，可伸缩性很差 * @param user */ public void addUser(String user) { synchronized(users) { users.add(user); } } public void addQuery(String q) { synchronized(queries) { queries.add(q); } } public void removeUser(String user) { synchronized(users) { users.remove(user); } } public void removeQuery(String query) { synchronized(queries) { queries.remove(query); } } }

当处理器增加时，分解锁的性能不能持续提升，所以，可以使用分段锁，要求是数据独立同分布，每个锁保护一部分数据。

/ * buckets[n]由locks[n % N_LOCKS]来保护 */ public class StrippedMap { private static final int N_LOCKS = 16; private final Node[] buckets; private final Object[] locks; private static class Node{ Object key; Object value; Node next; Node(Object key, Object value) { this.value = value; this.key = key; } void setNext(Node next) { this.next = next; } } public StrippedMap(int numBuckets) { buckets = new Node[numBuckets]; locks = new Object[N_LOCKS]; for(int i = 0; i < N_LOCKS; i++) { locks[i] = new Object(); } } private final int hash(Object key) { return Math.abs(key.hashCode() % buckets.length); } public Object get(Object key) { int hash = hash(key); synchronized (locks[hash % N_LOCKS]) { for(Node m = buckets[hash]; m != null; m = m.next) { if(m.key.equals(key)) { return m.value; } } } return null; } public void put(Object key, Object value) { int hash = hash(key); synchronized (locks[hash % N_LOCKS]) { Node node = buckets[hash]; Node preNode = node; while (node != null) { preNode = node; node = node.next; } Node currentNode = new Node(key,value); currentNode.setNext(null); if(preNode == null) { buckets[hash] = currentNode; return; } preNode.setNext(currentNode); return; } } public void clear() { for(int i = 0; i < buckets.length; i++) { synchronized (locks[i % N_LOCKS]) { buckets[i] = null; } } } public static void main(String[] args) { StrippedMap map = new StrippedMap(16); map.put("test", 123); map.put("test1", 1); map.put("abs", 1); System.out.println(map.get("abs")); System.out.println(map.get("test")); System.out.println(map.get("test1")); } }

对锁的优化，是建立在保证程序正确性的基础上的，所以，先保证程序能正常运行，当吞吐量达不到期望时，才能考虑性能优化，过早的优化就是灾难。

参考《Java并发编程实战》