随手记：巧妙设计，并发场景下突破常规synchronize，提高读写效率

1、Peterson 算法（Dekker算法的演化），这个算法设计得很巧妙，理解的核心就是搞清楚三个标志位是怎样控制两个方法对临界区的访问的：

volatile int flag1 = 0; //主观因素：flag1表示方法1自身是否要求进入临界区 
volatile int flag2 = 0; //主观因素：flag2表示方法2自身是否要求进入临界区 
volatile int turn = 1; //客观因素：turn取1和2分别表示当前临界区针对方法1还是方法2开放

void fun1(){ 
  flag1 = 1; 
  turn = 2; 
  while( flag2==1 && turn==2 ){} //只有在方法2自身要求进入临界区且临界区针对方法2开放时，方法1才会阻塞 
  //Critical Section 
  ... //临界区内 
  flag1 = 0; 
} 

void fun2(){ 
  flag2 = 1; 
  turn = 1; 
  while( flag1==1 && turn==1 ){} //只有在方法1自身要求进入临界区且临界区针对方法1开放时，方法1才会阻塞 
  //Critical Section 
  ... //临界区内 
  flag2 = 0; 
}

 

 

 

2、ConcurrentHashMap，设计巧妙，用桶粒度的锁，避免了put和get中对整个map的锁定，尤其在get中，只对一个HashEntry做锁定操作，性能提升是显而易见的。

细节参见 http://www.iteye.com/topic/344876 ，有详细的讨论。

Mark: https://www.ibm.com/developerworks/java/library/j-jtp08223/ ，这里有关于Java内存模型结合ConcurrentHashMap的分析。

 

3、主题泛化：无锁（Lock-Free）并发编程

在Lock-Free世界里，最简单也最普遍的一个通用原语是CAS(Compare and Swap)操作。支持并发的现代的处理器都提供了这个原语的硬件实现。CAS原语负责比较某个内存地址处的内容与一个期望值，如果比较成功则将该内存地址处的内容替换为一个新值。这整个操作是原子的。

这里有对无锁并发编程的介绍：http://www.cnblogs.com/lucifer1982/archive/2008/04/16/1154727.html

Java并发框架汇总：http://www.groovyq.net/content/java%E5%B9%B6%E5%8F%91%E6%A1%86%E6%9E%B6%E5%9B%9E%E9%A1%BE

 

最后，这里有一个专题页：

https://www.ibm.com/developerworks/cn/java/j-concurrent/

 

PS：HashMap不是线程安全的，错误的使用并发状况下可能出现CPU100%的状况，在性能问题定位中遇到了，记录：

/** 
* Transfers all entries from current table to newTable. 
*/ 
void transfer(Entry[] newTable) { 
    Entry[] src = table; 
    int newCapacity = newTable.length; 
    for (int j = 0; j < src.length; j++) { 
        Entry e = src[j]; 
        if (e != null) { 
            src[j] = null; 
            do { 
                Entry next = e.next; 
                int i = indexFor(e.hash, newCapacity); 
                e.next = newTable[i]; 
                newTable[i] = e; 
                e = next; 
            } while (e != null); 
        } 
    } 
}

 

问题最终就出现在HashMap中transfer方法的这个while循环上，这个方法在HashMap扩容时调用，详细分析见：

http://blog.sina.com.cn/s/blog_56146a210100owft.html