细密相关的同步化行列此刻来看一种细密相关的同步方法。一个或多个出产者线程出产数据，并由一个或多个消费者线程凭据先进先出的序次来获取。可是，出产者与消费者之间必需彼此回合，即向行列中放入一个元素的出产者应阻塞直到该元素被别的一个消费者取出，反之亦然。其实现的伪代码描写如下：

publicclassSynchronousQueue<T>{

      T item=null;
      booleanenqueuing;
      Lock lock;
      Condition condition;

      publicvoidenq(T value){
         lock.lock();
         try{
            while(enqueuing){
               condition.await();
            }

            enqueuing=true;
            item=value;
            condition.signalAll();

            while(item!=null)
               condition.await();
            enqueuing=false;
            condition.signalAll();
         }finally{
            lock.unlock();
         }
      }

      public T deq(){
         lock.lock();

         try{
            while(item==null)
               condition.await();
            T t=item;
            item=null;
            condition.signalAll();
            return t;
         }finally{

            lock.unlock();
         }
      }
   }

这是一种基于管程的同部行列实现。由于这个行列设计很是简朴，所以他的同步价钱很高。在每个线程大概叫醒另一个线程的时间点，软件开发，无论是入队者照旧出队者城市叫醒所有的期待线程，从而叫醒的次数是期待线程数目标平方。尽量可以利用条件工具来淘汰叫醒次数，但由于仍需要阻塞每次挪用，所以开销很大。

为了淘汰同部行列的同步开销，我们思量别的一种同部行列的实现，在该实现中将入队与出队分两步完成。如出队从一个空行列删除元素的进程为，第一步，他将一个保存工具放入行列，暗示该出队者这在期待一个筹备与之汇合的入队者。然后，出队者在这个保存工具的flag符号上自旋期待。第二步，当一个入队者发明该保存时，他通过存放一个元素并配置保存工具的flag来通知出队者完成保存。同样，入队者也可以或许通过建设本身的保存工具，并在保存工具的flag符号上自旋来期待会条约伴。在任意时刻，行列自己可能包括出队者的保存工具可能包括入队者的保存工具，可能为空。因此操纵行列的线程共有4种交互工具，即入队者线程、入队者保存、出队者线程、出队者保存，由于需要举办细密的同步，因此他们之间的对应干系如下：

入队者线程————>出队者保存；

出队者线程————>入队者保存；

即入队者线程要协助处理惩罚出队者保存，同样出队者线程要协助处理惩罚入队者保存。这种布局称为双重数据布局，其焦点是要领是通过两个步调来生效的：保存和完成。该布局具有许多很好的性质。首先，正在期待的线程可以在一个当地缓存符号上自旋，而这时可扩展性的基本。其次，图纸加密，他很自然的担保了公正性。保存凭据他们达到的序次来列队，从而担保请求也凭据同样的序次完成，因此这种布局是可以线性化的，因为每个部门要领挪用在他完成时是可以排序的。

该行列布局可以用节点构成的链表来实现，个中节点可能暗示一个期待出队的元素可能暗示一个期待完成的保存，由节点的Type域指定。任何时候，所有的行列节点都应具备沟通的范例，即可能全部是期待出队的元素，可能全部是期待完成的保存。当一个元素入队时，节点的item域存放该元素；当元素出队时，节点的item域被从头配置为null。当一个保存入队时，节点的item域为null；当保存被一个入队者完成时，节点的item域被从头配置为一个元素。

因此首先界说一个Java列举，来暗示节点的范例，然后界说链表的节点元素，在整个实现进程中，依然基于Java的原子化操纵来实现并发节制，所以源代码如下所示：

publicenumNodeType {

 ITEM,RESERVATION;

}

个中，ITEM代表节点元素，RESERVATION代表保存工具。

import java.util.concurrent.atomic.AtomicReference;

publicclassSynNode<E> {

   volatileNodeType type;//节点范例
   //节点元素，元素值为Java泛化范例

   volatileAtomicReference<E> item;

   volatileAtomicReference<SynNode<E>> next;

   SynNode(E eitem,NodeType etype){

      item=newAtomicReference<E>(eitem);
      next=newAtomicReference<SynNode<E>>(null);
      type=etype;
  }
}

接下来界说行列的主体实现，个中主要包罗：入队和出对操纵。

import java.util.concurrent.atomic.AtomicReference;

publicclassSynchronousDualQueue<E> {
  privateAtomicReference<SynNode<E>> head,tail;//头尾哨兵节点
  publicSynchronousDualQueue(){

//初始化空行列，建设一个具有任意值的节点，并让头尾指针指向该节点
     SynNode<E> snode=new SynNode<E>(null,NodeType.ITEM);
     head=newAtomicReference<SynNode<E>>(snode);
     tail=newAtomicReference<SynNode<E>>(snode);
  }

//入队操纵
  publicvoidenq(E item){

      //建设将被入队的新节点
      SynNode<E> offer=newSynNode<E>(item,NodeType.ITEM);

      while(true){

         //获取头尾哨兵节点
         SynNode<E> t=tail.get();
         SynNode<E> h=head.get();
         
         //检讨行列是否为空可能是否包括已入队元素的出队保存
         if(t==h||t.type==NodeType.ITEM){
            //读取tail节点的后继
            SynNode<E> n=t.next.get();
            //判定读取的tail值是一致的，即tail的状态不会被并发线程变动
            if(t==tail.get()){
               //假如tail域没有指向行列的最后一个节点，则实验推进tail,并从头开始
               if(n!=null){
                  //实验推进tail
                   tail.compareAndSet(t,n);
               }

                  //假如tail域就是行列最后一个元素，那么实验将tail的后继指向新增节点，//即将新增节点挂接到队尾
                  elseif(t.next.compareAndSet(n,offer)){
                  //假如乐成挂接，那么实验推进tail域，使其指向新增节点
                   tail.compareAndSet(t,offer);
                   //自旋期待，期待一个出队者通过配置该节点的item域为null来通知该元素已//经出队。这是因为这是一个细密同步的行列，入队元素必需期待利用它的出队//者
                   while(offer.item.get()==item);
                  //一旦出队乐成，就实验移动头指针，以便举办清理。这是因为出队是从新节点//出队。通过将新增节点配置为head哨兵节点，实现对被利用节点的清理
                   h=head.get();
                   if(offer==h.next.get()){
                      head.compareAndSet(h,offer);
                   }
                   return;
               }
            }
         }

         //假如存在正在期待完成的出队者的保存，那么就找出一个保存并完成它

         else{
            //读取head的后继节点
           SynNode<E> node=h.next.get();

           //判定读到的值是一致的，即运行进程中状态的一致性不能被并发线程所粉碎，//主要通过尾指针是否一致、头指针是否一致、以及首节点是否为空来判定，这//些状态都大概在运行中被并发线程改变，因此只要有一个状态被改变，即认为//整体状态被粉碎了，需要从头开始
           if(t!=tail.get()||h!=head.get()||node==null){

              continue;
           }

           //假如状态一致，那么实验着将节点的item域从null改为要入队的元素。因为//出队者保存期待的是一个入队者，所以要将item域由null置为入队元素的//item

           boolean success=node.item.compareAndSet(null,item);
           //不管上一步是否乐成，都实验推进head

           head.compareAndSet(h,node);
            //假如推进head乐成，该要领返回，不然重试

           if(success){
              return;
           }
         }
      }
  }

//出队操纵，其操纵逻辑与入队基内情似，劳务派遣管理系统，在此不再赘述

public E deq(){

      E result=null;
      while(true){
         SynNode<E> h=head.get();
         SynNode<E> t=tail.get();
         if(h==t || h.type==NodeType.ITEM){
            SynNode<E> n=h.next.get();
            if(h==head.get()){
               if(n==null){
                   tail.compareAndSet(t,new SynNode<E>(null,NodeType.RESERVATION));
               }elseif(head.compareAndSet(h,n)){
                   while(n.item.get()==null);
                   t=tail.get();
                   if(n==t.next.get()){
                      result=n.item.get();
                      tail.compareAndSet(t,n);
                   }
                   return result;
               }
            }
         }
         else{
            SynNode<E> node=t.next.get();
            result=node.item.get();
            if(t!=tail.get()||h!=head.get()||node==null){
               continue;
            }

            boolean success=node.item.compareAndSet(result,null);
            tail.compareAndSet(t,node);
            if(success){
               return result;
            }
         }
      }
  }
}