Lock-free BlockingStack

Дмитрий Вьюков в комментах спрашивает "А слабо к этому стеку прикрутить блокирующую семантику, что бы pop() на пустом стеке блокировался до появления элемента, и так что бы стек оставался lock-free пока есть элементы?". Отвечаю - не слабо:

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

public class LockFreeBlockingStack {
  private final AtomicReference head = new AtomicReference(null);
  private final Queue popWaiters = new ConcurrentLinkedQueue();

  public void push(int data) {
      for (; ;) {
          Node next = (Node) head.get();
          Node myNode = new Node(data, next);
          if (head.compareAndSet(next, myNode)) {
              LockSupport.unpark(popWaiters.peek());              
              return;
          }
      }
  }

  public int pop() {
      for (; ;) {
          Node currHead = (Node) head.get();
          if (currHead == null) {
              boolean wasInterrupted = false;
              Thread current = Thread.currentThread();
              popWaiters.add(current);

              while (popWaiters.peek() != current || (currHead = (Node) head.get()) == null) {
                  LockSupport.park(this);
                  if (Thread.interrupted()) {// ignore interrupts while waiting
                      wasInterrupted = true;
                  }
              }

              popWaiters.remove();
              if (wasInterrupted) { // reassert interrupt status on exit
                  current.interrupt();
              }
          }
          if (head.compareAndSet(currHead, currHead.next)) {
              return currHead.data;
          }
      }
  }

  private static class Node {
      private final int data;
      private final Node next;

      public Node(int data, Node next) {
          this.data = data;
          this.next = next;
      }
  }
}

0) в коде могут быть ошибки
1) кстати, пример использования java.util.concurrent.LockSupport
2) хотя очередь popWaiters FIFO итоговая конструкция вышла non-fair практически аналогично рассказываемой мной на лекции причины нечестности synchronized секции, а именно в pop()
Node currHead = (Node) head.get();
if (currHead == null) {
т.е. сразу лезем получить данные и только если их нет пойдем вставать в очередь
popWaiters. Если же кто-то вызвал pop()
if (head.compareAndSet(next, myNode)) {
LockSupport.unpark(popWaiters.peek());
return;
т.е. положил данные и разбудил спящего в очереди, но проснувшегося мог опередить новый поток вызвавший pop и получить данное в обход очереди.
3) думаю данный функционал возможно реализовать также на Thread.suspend()/resume(). Надо подумать.
4) Это решение рождено в процессе анализа этого кода

class FIFOMutex {
   private final AtomicBoolean locked = new AtomicBoolean(false);
   private final Queue waiters
     = new ConcurrentLinkedQueue();

   public void lock() {
     boolean wasInterrupted = false;
     Thread current = Thread.currentThread();
     waiters.add(current);

     // Block while not first in queue or cannot acquire lock
     while (waiters.peek() != current ||
            !locked.compareAndSet(false, true)) {
        LockSupport.park(this);
        if (Thread.interrupted()) // ignore interrupts while waiting
          wasInterrupted = true;
     }

     waiters.remove();
     if (wasInterrupted)          // reassert interrupt status on exit
        current.interrupt();
   }

   public void unlock() {
     locked.set(false);
     LockSupport.unpark(waiters.peek());
   }
 }

из javadoc к LockSupport
5) Дмитрий, Вы данное решение имели в виду? Или есть другое?