一、性能和可伸缩性
1、可伸缩性：当增加计算资源时（例如CPU、内存、存储容量或IO带宽），程序的吞吐量或者处理能力相应地增加。
2、在并发程序中，对可伸缩性的主要威胁就是独占式的资源锁。我们知道，串行操作会降低可伸缩性，并且上下文切换也会降低性能。在锁上竞争时将同时导致这两种问题，因此减少锁的竞争能够提高性能和可伸缩性。
3、有三种方式可以降低锁的竞争程度：
a）减少锁的持有时间；
【缩小锁的范围{同步代码块 - 而不是修饰方法}、减小锁的粒度{锁分解和锁分段等技术 - 采用多个相互独立的锁来保护独立的状态变量，从而改变这些变量在之前由单个锁来保护的情况 - 这些技术能减小锁操作的粒度，并能实现更高的可伸缩性，然而，使用的锁越多，那么发生死锁的风险就越高}】
- 锁分解
如果一个锁需要保护多个相互独立的状态变量，那么可以将这个锁分解为多个锁，并且每个锁只保护一个变量，从而提高可伸缩性，并最终降低每个锁被请求的频率。
设想一下，如果在整个程序中只有一个锁，而不是为每个对象分配一个独立的锁，那么，所有同步代码块的执行就会变成串行化执行，而不考虑各个同步块中的锁。由于很多线程将竞争同一个全局锁，因此两个线程同时请求这个锁的概率将剧增，从而导致严重的竞争。
public class ServerStatus{
public final Set<String> users;
public final Set<String> queries;
public synchronized void addUser(String u){
users.add(u);
}
public synchronized void addQuery(String u){
queries.add(u);
}
......//其他方法
} public class ServerStatus{
public final Set<String> users;
public final Set<String> queries;
public void addUser(String u){
synchronized (users){
users.add(u);
}
}
public synchronized void addQuery(String u){
synchronized (queries){
queries.add(u);
}
}
......//其他方法
}- 锁分段
把一个竞争激烈的锁分解为两个锁时，这两个锁可能都存在激烈的竞争。在某些情况下，可以将锁分解技术进一步扩展为对一组独立对象上的锁进行分解，这种情况被称为锁分段。典型的示例就是ConcurrentHashMap，在ConcurrentHashMap的实现中使用了一个包含16个锁的数组，每个锁保护所有散列桶的1/6，其中第N个散列桶由第（N mod 16）个锁保护。
锁分段的一个劣势在于：与采用单个锁来实现独占式访问相比，要获取多个锁来实现独占访问将更加困难并且开销更高。通常，在执行一个操作时最多只需获取一个锁，但在某些情况下需要加锁整个容器，例如当ConcurrentHashMap需要扩展映射范围，以及重新计算键值的散列值要分布到更大的桶集合中时，就需要获取分段锁集合中的所有的锁。
public class StripedMap{
//同步策略：buckets[n]由locks[n%N_LOCKS来保护]
private static final int N_LOCKS = 16;
private final Node[] buckets;
private final Object[] locks;
private static class Node{......}
public StripedMap(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]){
....
}
...
}
public void clear(){
for (int i = 0;i<buckets.length;i++){
synchronized (locks[i % N_LOCKS]){
buckets[i] = null;
}
}
}
......
}b）降低锁的请求频率；
c）使用带有协调机制的独占锁，这些机制允许更高的并发性；
第三种降低竞争锁影响的技术就是放弃使用独占锁，从而有助于使用一种友好并发的方式来管理共享状态。例如，使用并发容器、读-写锁、不可变对象以及原子变量。
ReadWriteLock实现了一种在多个读操作以及单个写操作情况下的加锁规则：如果多个读取操作都不会修改共享资源，那么这些读取操作可以同时访问该共享资源，但在执行写入操作时必须以独占方式来获取锁。
原子变量提供了一种方式来降低更新“热点域”时的开销。
4、向“对象池”说不
现在Java的分配操作已经比C语言的malloc调用更快，在并发程序中，对象池表现更加槽糕。当线程分配新的对象时，基本上不需要再线程之间进行协调，因为对象分配器通常会使用线程本地的内存块，所以不需要再堆数据结构上进行同步。然而，如果这些线程从对象池中请求一个对象，那么就需要通过某种同步来协调对象池数据结构的访问，从而可能是某个线程被阻塞。对象池有其特定的用途，但对于性能优化来说，用途很有限。通常，对象分配操作的开销比同步的开销更低。
二、显式锁
在Java 5.0之前，在协调对共享对象的访问时可以使用的机制只有synchronized和volatile。Java 5.0 增加了一种新的机制：ReentrantLock。与之前提到过得机制相反，ReentrantLock并不是一种替代内置锁的方法，而是当内置锁机制不适用时，作为一种可选择的高级功能。
2.1、Lock与ReentrantLock
Lock接口提供了一种无条件的、可轮询的、定时的以及可中断的锁获取操作，所有加锁和解锁的方法都是显式的。在Lock的实现中必须提供与内部锁相同的内存可见性语义，但在加锁语义、调度算法、顺序保证以及性能特性等方面可以有所不同。
ReentrantLock实现了Lock接口，并提供了与synchronized相同的互斥性和内存可见性。与synchronized一样，ReentrantLock还提供了可重入的加锁语义，与synchronized相比，它还为处理锁的不可用性问题提供了更高的灵活性。
Lock lock = new ReentrantLock();
...
lock.lock();
try{
......
}finally {
lock.unlock();
}2.2、轮询锁与定时锁 - tryLock
while(true){//轮询
//Account中的lock变量
if (fromAccount.lock.tryLock()){
if (toAccount.lock.tryLock()){
}finally{
toAccount.lock.unlock();
}
}finally{
fromAccount.lock.unlock();
}
}if(!lock.tryLock(3000,NANOSECONDS)){
return false;
}
try{
......
}finally {
lock.unlock();
}2.3、可中断的锁获取操作
try{
try{
lock.lockInterruptubly();
}catch(Exception e){
e.printStackTrace();
}
}finally {
lock.unlock();
}2.4、内置锁与ReentrantLock之性能比较
在Java 5.0 中，ReentrantLock能提供更高的吞吐量，但在Java 6 中，二者的吞吐量非常接近了。因为Java6使用了改进后的算法来管理内置锁。2.5、公平性
在ReentrantLock的构造函数中提供了两种公平性选择：创建一个非公平（默认）的锁或者一个公平的锁。在公平锁上，线程将按照它们发出的请求的顺序来获得锁，但在非公平的锁上，则允许“插队”：当一个线程请求非公平锁时，如果在发出请求的同时该锁的状态变为可用，那么这个线程将跳过队列中所有的等待线程并获得这个锁。2.6、synchronized和ReentrantLock之间的选择
在一些内置锁无法满足需求的情况下，ReentrantLock可以作为一种高级选择工具。当需要一些高级功能时才应该使用ReentrantLock，这些功能包括：可定时的、可轮询的与可中断的锁获取操作，公平队列，以及非块结构锁。否则，还是应该使用synchronized。2.7、读 - 写锁
public interface ReadWriteLock {
/**
* Returns the lock used for reading.
*
* @return the lock used for reading.
*/
Lock readLock();
/**
* Returns the lock used for writing.
*
* @return the lock used for writing.
*/
Lock writeLock();
}