几种锁算法的实现



Multicore

Abstract

4种Lock的实现：

• TASLock
• TTASLock
• CLHLock
• MCSLock

---

TASLock

每一个Lock带有一个状态位，lock()与unlock()操作原子的改变状态位。
false时可进入，true时spin。

public class TASLock implements Lock
{
    AtomicBoolean state = new AtomicBoolean(false);
    public void lock()
    {
        while(state.getAndSet(true))
        {}
    }

    public void unlock()
    {
        state.set(false);
    }
}

defect：

• 在锁被其他线程持有的情况下，while(state.getAndSet(true))会不停的将
  state从true改为true

TTASLock

TASLock算法的改进。

public class TTASLock implements Lock()
{
    AtomicBoolean state = new AtomicBoolean(false);
    public void lock()
    {
        while (true)
        {
            while (state.get())
            {};
            if (! state.getAndSet(true))
                return;
        }
    }

    public void unlock()
    {
        state.set(false);
    }
}

1. while (state.get()){}是一个改进，效果是先看一眼lock的状态，当lock是false时，
   再真正的执行state.getAndSet(true)。
2. 当state.getAndSet(true) 的return为false时，说明之前的确是false，于是获得锁，return。
   否则回到while(true),再次尝试获得锁。

defect：

• 在unlock时，state.set(false)还是会带来大量的cache miss。
• cache miss VS cache hit

CLHLock

队列锁。
CLHLock

void initCLHlock()
{
    q.locked = FALSE;
    tail = &q;
}

void lock()
{

    QNode* qnode = (QNode*)pthread_getspecific(myNode);
    qnode->locked = TRUE;
    QNode* pred = getAndSet(qnode);//原子的得到队尾，并将qnode设为新的队尾。
    pthread_setspecific(myPred, pred);


    while(pred->locked)
    {
    }

}


void unlock()
{
    QNode* qnode = (QNode*)pthread_getspecific(myNode);
    qnode->locked = FALSE;
    QNode* pred = (QNode*)pthread_getspecific(myPred);
    pthread_setspecific(myNode, pred);//unlock时必须将myNode指向前面的Node
}

NOTE:

• unlock时必须将myNode指向前面的Node！
  > 后果：如果Thread A unlock()后，紧接着又进入
  队尾， A的locked会再次被置为TRUE， Thread B还在看着Thread A 的locked字段，于是产生
  deadlock。
• 初始时教室里面有一个空凳子， 每个学生来到门口排队时都自己带着一个凳子。

MCSLock

public class MCSLock implements Lock
{
    AtomicReference<QNode> tail;
    ThreadLocal<QNode> myNode;
    public MCSLock()
    {
        queue = new AtomicReference<QNode>(null);
        myNode = new ThreadLocal<QNode>()
        {
            protected QNode initialValue()
            {
                return new QNode();
            }
        };
    }
    ...
    class QNode
    {
        boolean locked = false;
        QNode next = null;//与CLHLock相比，多了这个真正的next
    }
}   

public void lock()
{
    QNode qnode = myNode.get();
    QNode pred = tail.getAndSet(qnode);
    if (pred != null)
    {
        qnode.locked = true;
        pred.next = qnode;
        //wait until predecessor gives up the lock
        while(qnode.locked){}//将自己设为true然后spin，看似deadlock
    }
}
public void unlock()
{
    QNode qnode = myNode.get();
    if (qnode.next == null)         //后面没有等待线程的情况
    {//------there is a gap!!!!
        if (tail.compareAndSet(qnode, null))
            return;                 //真的没有等待线程，则直接返回，不需要通知
        //wait until predecessor fills in its next field
        while (qnode.next == null){}
    }
    //右面有等待线程，则通知后面的线程
    qnode.next.locked = false;
    qnode.next = null;
}

NOTE:

• unlock()要要特别的注意。

Summary

• CLHLock的思想是当前线程在前一个线程的node上spin，每个线程unlock时修改自身的标记。
  在共享总线结构下性能可以，无法应对分布式。
• MCSLock 用于解决分布式并行的问题。每个线程都在自己的node上spin，当释放锁时通知
  后面的线程。