Art of Multiprocessor Programming 答案 ch6

77. 将确定顺序规范的对象变成确定顺序规范: 

做不确定顺序规范到确定顺序规范的映射或者将Node变成ConsensusNode,即给Node一个consensus wrapper，保证不确定的输出将在各个线程中的道一致的确定的输出。

78. 无等待的算法会出错。seq == 0会被当作需要加到list当中的Node ==> tail->next = tail.

79. 不明白“不用通用构造”又“改造这个算法”是什么意思。还是用的通用构造

package p79;import java.util.concurrent.atomic.AtomicReference;public class Consensus<T>{private AtomicReference<T> curObj;public Consensus(){this.curObj = new AtomicReference<T>();curObj.set(null);}public T decide(T next){curObj.compareAndSet(null, next);return curObj.get();}}

package p79;public class Node {public Node next;public int seq;public int exp;public int v;public Consensus<Node> decideNext;public Node(){this.seq = 0;this.next = null;decideNext = new Consensus<Node>();}public Node(int exp, int replace){this();this.exp = exp;this.v = replace;}public static Node max(Node[] array){Node max = array[0];for(int i = 1; i < array.length; i ++){if(max.seq < array[i].seq){max = array[i];}}return max;}}

package p79;public class Universal_CAS{private Node[] announce;private Node[] head;private Node tail;private int n;private static ThreadLocal<Integer> ThreadId = new ThreadLocal<Integer>(){protected Integer initialValue(){return new Integer(0);}};public Universal_CAS(int n){this.n = n;tail = new Node();tail.seq = 1;announce = new Node[n];head = new Node[n];for(int i = 0; i < n; i ++){announce[i] = tail;head[i] = tail;}}public int read(){Node max = Node.max(head);return max.v;}public boolean compareAndSet(int exp, int replace){ int i = ThreadId.get(); announce[i] = new Node(exp, replace); head[i] = Node.max(head); Node before = null; while(announce[i].seq == 0) { before = head[i]; Node help = announce[(before.seq + 1) % n]; Node prefer = help; if(help.seq != 0) { prefer = announce[i]; }  Node after = before.decideNext.decide(prefer); before.next = after; after.seq = before.seq + 1; if(before.v != after.exp) { after.v = before.v; }  head[i] = after; }  boolean rc = false; if(before.v == announce[i].exp) { announce[i].v = replace; rc = true; }else { announce[i].v = before.v; } head[i] = announce[i]; return rc;}}

80. 如果每个线程首先尝试加入自己的结点，在announce[i].seq !=0 后就推出apply()方法，仍然会出现有的线程一直成功而有的线程饿死的状况。如果线程成功的加入自己的结点后开始尝试帮助其它的线程，例如将While()中的帮助循环n-1次，应该是可以的。

81. 将max方法改成下面这样，然后用max(tail)来得到head[i]

package p79;public class Node {public Node next;public int seq;public int exp;public int v;public Consensus<Node> decideNext;public Node(){this.seq = 0;this.next = null;decideNext = new Consensus<Node>();}public Node(int exp, int replace){this();this.exp = exp;this.v = replace;}public static Node max(Node tail){Node pre = tail;while(pre.next != null){pre = pre.next;}return pre;}}

82.

1. 因为有可能节点 seq已经设置，但是节点没有放到head[]中，

所以实际上的start(A) = m + 1，但是head[A].seq用Node.max()计算出来为m，

使6.4.4不成立。

2.仍然能够正常工作。

因为这种情况下有(head[A].seq - start(A)) >= -1。

假设(head[A].seq - start(A)) < -1，比如 = -2；则必然在head[A]后至少有2个节点增加到链表中。假设他们的seq为m + 1, m + 2。

如果设置 m +2的线程从 head[]中得到m + 1的值，则这个不等式成立；

如果从链表中得到m + 1的值，则这个线程必然已经在while()循环中完成了after.seq = m + 1，head[i] = after的一轮操作，即m + 1已经被这个线程加到head中。

所以这个不等式总是成立。

根据这个不等式，和Theorem 6.4.1的推导方法，线程经过了最多(n + 1)次迭代后仍然能将自己的announce设置到head中。

83.

 利用新添加的before和新添加的calculated flag。和java 垃圾搜集。tail的calculated初始化为true。
当用before.next = after构建链表时，也用 after.before = before构建双向链表。
完成将announce添加到链表的操作后，计算log值时，不从tail开始，而是从current向before利用反向链表，直到找到一个before.calculated = true的node，作为初始值开始计算本线程的local log。
当head[i]的值计算完毕，calculated设置完毕后head[i].before = null；使节点脱离反向链表。
但是如果一个线程中途退出了，它将由head[i] hold住无限长的 next链表。所以其他线程也要帮助它脱离next链表。
准备一个全局的dummy node，它将作为next的填充物，防止before.next.decide在脱链后又被加入新的节点。
每个线程在计算完自己的log后帮助其他线程的过时head脱链：
检查每个head[j].seq。如果(current.seq - head[j].seq) >( n + 1)；假设head[j].seq = m，则必然已经有一个node.seq = (m + 1)的calculated = true。即这个node已经不需要了。所以将head[j].next = dummy。
但是其他的线程在沿着链表遍历的时候可能会遇到这个节点。如果使用的是这个节点本身，或者它的before/next节点值，线程都能够发现这个节点的异常，比如after = before.next.decide() ; after == dummy。线程可以重新计算max重来。
因为这个处理并不影响线程的seq关系，所以无等待没有影响。
这个过时的节点可能会被附上新的before节点，但是当before关系被用到时，这个节点自身的calculated已经被置位，所以不会有被反向链表用到的时候。而新被链入的before节点在这个过时节点本身从next链中摘除并回收的时候，新加入的before节点也会被解除被引用的关系。


84.