Java5 Concurrent包中的锁机制
JDK1.5以后加入了concurrent包，主要是为了提高多线程的开发效率，其中提供了很多支持并发的集合类，其中包括：ConcurrentHashMap。大家知道HashTable也是支持并发环境的，也就是说多线程安全的，那两者有什么区别呢？
分析
其实简单的说是同步机制有区别，具体区别又在那里呢？
请看HashTable的put方法：
/**
* Maps the specified key to the specified
* value in this hashtable. Neither the key nor the
* value can be null.
*
* The value can be retrieved by calling the get method
* with a key that is equal to the original key.
*
* @param key the hashtable key
* @param value the value
* @return the previous value of the specified key in this hashtable,
* or null if it did not have one
* @exception NullPointerException if the key or value is
* null
* @see Object#equals(Object)
* @see #get(Object)
*/
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
modCount++;
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
Entry e = tab[index];
tab[index] = new Entry(hash, key, value, e);
count++;
return null;
}
代码中使用synchronized函数的方式进行同步，这个类的其他方法也是使用这个机制进行同步的。我们先来大致了解一下synchronized的机制：
在多线程环境中，Java的对象都会隐式的包含有一个同步队列，其中类会有一个，然后每个类实例也会包含一个。如图：
class Foo {
synchronized void doSomething(); // 把同步的线程放入类实例的同步队列
synchronized static void doSomething(); //把同步的线程放入类的同步队列
}
然后我们再来看看ConcurrentHashMap 的put方法：
//ConcurrentHashMap
public V put(K key, V value) {
if (value == null)
throw new NullPointerException();
int hash = hash(key.hashCode());
return segmentFor(hash).put(key, hash, value, false);
}
//Segment内部类，继承至ReentrantLock
V put(K key, int hash, V value, boolean onlyIfAbsent) {
lock();
try {
int c = count;
if (c++ > threshold) // ensure capacity
rehash();
HashEntry[] tab = table;
int index = hash & (tab.length - 1);
HashEntry first = tab[index];
HashEntry e = first;
while (e != null && (e.hash != hash || !key.equals(e.key)))
e = e.next;
V oldValue;
if (e != null) {
oldValue = e.value;
if (!onlyIfAbsent)
e.value = value;
}
else {
oldValue = null;
++modCount;
tab[index] = new HashEntry(key, hash, first, value);
count = c; // write-volatile
}
return oldValue;
} finally {
unlock();
}
}
ReentrantLock就是Java Concurrent包提供的锁对象，Lock的使用方法大致如下：
Lock l = ...;
l.lock();
try {
// access the resource protected by this lock
} finally {
l.unlock();
}
为什么使用Lock对象会比使用synchronized有更好的性能呢？我们再来看看ReentrantLock的实现：
public class ReentrantLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = 7373984872572414699L;
/** Synchronizer providing all implementation mechanics */
private final Sync sync;
/**
* Base of synchronization control for this lock. Subclassed
* into fair and nonfair versions below. Uses AQS state to
* represent the number of holds on the lock.
*/
static abstract class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
..........
...........我们从中看到ReentrantLock对象也维护着一个同步队列，性能差别就在于这个队列的实现上，我们再来看AbstractQueuedSynchronizer的代码：
/**
* Inserts node into queue, initializing if necessary. See picture above.
* @param node the node to insert
* @return node's predecessor
*/
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
Node h = new Node(); // Dummy header
h.next = node;
node.prev = h;
if (compareAndSetHead(h)) {
tail = node;
return h;
}
}
else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
/**
* CAS head field. Used only by enq
*/
private final boolean compareAndSetHead(Node update) {
return unsafe.compareAndSwapObject(this, headOffset, null, update);//使用compare and swap方式
}
/**
* CAS tail field. Used only by enq
*/
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);//使用compare and swap方式
}
到了Unsafe.java这里就要通过本地代码实现了，下面是kaffe里面的本地代码实现：
/**
* Helper macro, defining a sun.misc.Unsafe compare and swap function
* with a given NAME tail and TYPE of arguments.
*/
#define KAFFE_UNSAFE_COMPARE_AND_SWAP(NAME, TYPE)
JNIEXPORT jboolean JNICALL Java_sun_misc_Unsafe_compareAndSwap ## NAME(JNIEnv* env, jobject unsafe UNUSED, jobject obj, jlong offset, TYPE expect, TYPE update)
{
volatile TYPE * address = getFieldAddress(env, obj, offset);
if (sizeof(TYPE) == sizeof(gint))
return g_atomic_int_compare_and_exchange((volatile gint *) address, (gint) expect, (gint) update);
else if (sizeof(TYPE) == sizeof(gpointer))
return g_atomic_pointer_compare_and_exchange((volatile gpointer *) address, (gpointer) expect, (gpointer) update);
else
if (*address == expect) {
*address = update;
return JNI_TRUE;
}
else
return JNI_FALSE;
}
再看glib的代码：
gboolean g_atomic_int_compare_and_exchange (volatile gint *atomic,
gint oldval,
gint newval)
{
gint result;
__asm__ __volatile__ ("lock; cmpxchgl %2, %1"
: "=a" (result), "=m" (*atomic)
: "r" (newval), "m" (*atomic), "0" (oldval));
return result == oldval;
}
AT&T汇编，
一条指令总会是原子性的了吧
总结
concurrent包中大量使用了新的锁机制，新的Lock机制最终归结到一个原子性操作上，所以会比使用synchronized关键字有更高的性能。
参考
关于Java多线程的一个PPT