Art of Multiprocessor Programming 答案 ch10

119.

  private enum NodeType {ITEM, RESERVATION, SENTINEL};

public class SynchronousDualQueue<T> {
  AtomicReference<Node> head;
  AtomicReference<Node> tail;  
  private final Node NullNode = new Node(null, NodeType.SENTINEL);
  
/* Replace all null with NullNode */
}

120.

package p120;

public class TwoThreadLockFreeQueue<T> 
{
	int head = 0, tail = 0;
	T[] items;
	
	@SuppressWarnings("unchecked")
	public TwoThreadLockFreeQueue(int capacity)
	{
		head = tail = 0;
		items = (T[]) new Object[capacity];
	}
	
	public void enq(T x)
	{
		//rmb
		while(tail - head == items.length) 
		{
			//rmb
		}
		
		items[tail % items.length] = x;
		tail ++;
		//wmb
	}
	
	public Object deq()
	{
		//rmb
		while(tail == head) 
		{
			//rmb 
		}
		
		Object x = items[head % items.length];
		head ++;
		//wmb
		return x;
	}
}

121.

package p121;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TwoLockArrayQueue
   
   
    
    
{
	private final int capacity;
	private int enqSideSize;
	private int deqSideSize;
	private Lock enqLock;
	private Condition enqCond;
	private Lock deqLock;
	private Condition deqCond;
	private int head;
	private int tail;
	private T[] datas;
	
	@SuppressWarnings("unchecked")
	public TwoLockArrayQueue(int cap)
	{
		capacity = cap;
		enqSideSize = 0;
		deqSideSize = 0;
		head = 0;
		tail = 0;
		enqLock = new ReentrantLock();
		deqLock = new ReentrantLock();
		enqCond = enqLock.newCondition();
		deqCond = deqLock.newCondition();
		
		datas = (T[]) new Object[capacity];
	}
	
	public void enq(T x)
	{
		boolean notifyDeq = false;
		
		enqLock.lock();
		try
		{
			while(enqSideSize == capacity)
			{
				deqLock.lock();
				try
				{
					enqSideSize = capacity - deqSideSize;
					deqSideSize = 0;
				}finally
				{
					deqLock.unlock();
				}
		
				if(enqSideSize == capacity)
				{
					enqCond.await();
				}
			}
			
			datas[tail % capacity] = x;
			tail ++;
			enqSideSize ++;
		
			//No notification lost as deqSideSize can only increase and still fit the condition
			if(enqSideSize - deqSideSize <= 1)
			{
				notifyDeq = true;
			}
			
		}catch(InterruptedException e)
		{
			e.printStackTrace();
		}finally
		{
			enqLock.unlock();
		}
		
		if(!notifyDeq) return;
		
		deqLock.lock();
		try
		{
			deqCond.signalAll();
		}finally
		{
			deqLock.unlock();
		}
	}
	
	public T deq()
	{
		T x = null;
		boolean notifyEnq = false;
		
		deqLock.lock();
		
		try
		{
			/*
			 * No notification lost as when enqSideSize increased in between while and await,
			 * there would always an enq thread knows enqSideSize - deqSideSize <= 1 
			 * and requires deqLock for notification. 
			 */
			while(deqSideSize >= enqSideSize)
			{
				deqCond.await();
			}
			
			x = datas[head % capacity];
			head ++;
			deqSideSize ++;

			if(enqSideSize >= capacity)
			{
				notifyEnq = true;
			}
		}catch(InterruptedException e)
		{
			e.printStackTrace();
		}finally
		{
			deqLock.unlock();
		}
		

		if(notifyEnq)
		{
			enqLock.lock();
			try
			{
				enqCond.signalAll();
			}finally
			{
				enqLock.unlock();
			}
		}
		return x;
	}
}

   
   

122. 必须。head.next != null --> deq 必须是原子的，否则可能有这样的case：queue中只有一个元素，2个线程deq，2个现成都得到head.next != null，然后2个现成分别在拿到锁之后deq，错误。

123.

使用SynchronousDualQueue, 在enq或deq消除（而不是加入list）的时候排除不符合要求的case。是分散的，低征用的，随机的。

package p123;

import java.util.concurrent.atomic.AtomicReference;

public class FeedOthers
   
   
    
     {
  AtomicReference
    
    
     
      head;
  AtomicReference
     
     
      
       tail;  

  public FeedOthers() {
    Node sentinel = new Node(null, NodeType.ITEM);
    head = new AtomicReference
      
      
       
       (sentinel);
    tail = new AtomicReference
       
       
         (sentinel); } public void enq(T e) { Node offer = new Node(e, NodeType.ITEM); while (true) { Node t = tail.get(); Node h = head.get(); if (h == t || t.type == NodeType.ITEM) { Node n = t.next.get(); if (t == tail.get()) { if (n != null) { tail.compareAndSet(t, n); } else if (t.next.compareAndSet(n, offer)) { tail.compareAndSet(t, offer); while (offer.item.get() == e); // spin h = head.get(); if (offer == h.next.get()) { head.compareAndSet(h, offer); } return; } } } else { Node n = h.next.get(); if (t != tail.get() || h != head.get() || n == null) { continue; // inconsistent snapshot } //fulltopic else if(n.type != NodeType.RESERVATION) { continue; } T other = n.item.get(); if(other.equals(e)) { // System.out.println("Can not eat from self "); continue; } boolean success = n.item.compareAndSet(other, e); head.compareAndSet(h, n); if (success) { return; } } } } public T deq(T me) { Node offer = new Node(me, NodeType.RESERVATION); //fulltopic while (true) { Node t = tail.get(); Node h = head.get(); if (h == t || t.type == NodeType.RESERVATION) { Node n = t.next.get(); if (t == tail.get()) { if (n != null) { tail.compareAndSet(t, n); } else if (t.next.compareAndSet(n, offer)) { tail.compareAndSet(t, offer); while (offer.item.get() == me); // spin h = head.get(); if (offer == h.next.get()) { head.compareAndSet(h, offer); } return offer.item.get(); } } } else { Node n = h.next.get(); if (t != tail.get() || h != head.get() || n == null) { continue; // inconsistent snapshot } //fulltopic else if(n.type != NodeType.ITEM) { continue; } T item = n.item.get(); if(item == null || item.equals(me)) { // System.out.println("Can not feed self "); continue; } boolean success = n.item.compareAndSet(item, null); head.compareAndSet(h, n); if (success) { return item; } } } } private enum NodeType {ITEM, RESERVATION}; private class Node { volatile NodeType type; volatile AtomicReference 
        
          item; volatile AtomicReference 
         
           next; Node(T item, NodeType type) { this.item = new AtomicReference 
          
            (item); this.next = new AtomicReference 
           
             (null); this.type = type; } public String toString() { return "Node[" + type + ", item: " + item + ", next: " + next + "]"; } } } 
            
           
          
         
       
      
      
     
     
    
    
   
   

124.

1. 应该以38行成功为线性化点，否则，

假设queue的状况是  head(A)-->B-->C-->sentinel

2个线程deq的执行顺序是  ThreadA.CAS --> ThreadB.CAS --> ThreadB.return --> ThreadA.return

以return为线性化点，返回结果应该是ThreadB得到A，ThreadA得到B; 但是算法的结果是 ThreadA得到A，ThreadB得到B。

2. enq的线性化点位16行成功。如果以tail更新为可线性化点，假设一个线程16行执行部成功，但是21行更新tail成功，则这个方法在没有实际enq的情况下使是方法的执行状态可见，这没有意义。

125.

1. enq是无等待的，因为每个调用能够在有限步完成。deq不是无锁的，假设只有一个deq线程，没有enq，这个线程运行无限步也不能完成一个调用。

2. 大概是这样：

deq()的可线性化点在13行成功地时刻。

对于enq和deq的操作，enq的可线性化点在第7行执行结束。

对于enq和enq的操作，enq的可线性化点在它们enq的值被deq成功的时刻，即第13行操作成功的时刻。

Reference: Reading the Linearizability paper of Herlihy and Wing