使用Treiber（1986年）算法的非阻塞链表-java版

1.认识

       构建非阻塞算法的窍门是：缩小原子化的范围到唯一的变量。

2.设计代码

 

 

package cn.it;

import scala.collection.mutable.Node;

import java.util.concurrent.atomic.AtomicReference;

class ConcurrentStackM<E> {
    AtomicReference<Node<E>>top=new AtomicReference<Node<E>>();
    public  void push(E item){
        Node<E>newHead=new Node<E>(item);
        Node<E>oldHead;
        do {
            oldHead=top.get();
            newHead.next=oldHead;

        }while (!top.compareAndSet(oldHead,newHead));

    }
    public E pot(){
        Node<E>newHead ;
        Node<E>oldHead;
        do {
            oldHead=top.get();
            if (oldHead==null){
                return null;
            }
            newHead=oldHead.next;

        }while (!top.compareAndSet(oldHead,newHead));
        return oldHead.item;

    }
    private static class Node <E>{
        public final E item;
        public Node<E>next;
        public Node(E item){
            this.item=item;
        }
    }
}

3.非阻塞链接队列算法

      该代码的LinkedQueue展示该算法插入部分（1996年）：

 

 

package cn.it;

import java.util.concurrent.atomic.AtomicReference;

public class LinkedQueue <E> {
    private static class Node <E>{
        final  E item;
        final  AtomicReference<Node<E>>next;
        public Node(E item,Node<E>next){
            this.item=item;
            this.next=new AtomicReference<Node<E>>(next);

        }

    }
    private final Node<E>dummy =new Node<E>(null,null);
    private  final AtomicReference<Node<E>>head=new AtomicReference<Node<E>>(dummy);
    private  final AtomicReference<Node<E>>tail=new AtomicReference<Node<E>>(dummy);
    
    public boolean put(E item){
        Node<E>newNode=new Node<>(item,null);
        while (true){
            Node<E>curTail=tail.get();
            Node<E>tailNext=curTail.next.get();
            if (curTail==tail.get()){
                if (tailNext !=null){
                    //队列处于静止状态，推进尾节点
                    tail.compareAndSet(curTail,tailNext);
                }
                else {
                    //处于静止状态，尝试插入新节点
                    if (curTail.next.compareAndSet(null,newNode)){
                        //插入成功，尝试推进尾节点
                        tail.compareAndSet(curTail,newNode);
                        return true;
                    }
                }
            }
        }
    }
}