HandOverHand implementation

package linkedlists.lockbased;

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

import contention.abstractions.AbstractCompositionalIntSet;

public class HandOverHand extends AbstractCompositionalIntSet {

  // sentinel nodes
  private Node head;
  private Node tail;

  public HandOverHand(){
    head = new Node(Integer.MIN_VALUE);
    tail = new Node(Integer.MAX_VALUE);
    head.next = tail;
  }

  private class Nodes{
    public Node curr;
    public Node pred;
    Nodes(Node curr, Node pred){
      this.curr = curr;
      this.pred = pred;
    }
  }
  private Nodes traverse(int item, Node curr, Node pred){
    while(curr.key < item){
      pred.unlock();
      pred = curr;
      curr = pred.next;
      curr.lock();
    }
    return new Nodes(curr, pred);
  }

  @Override
  public boolean addInt(int item){
    head.lock();
    Node pred = head;
    Node curr = pred.next;
    try{
      curr.lock();
      try{
        Nodes nn = traverse(item, curr, pred);
        curr = nn.curr; pred = nn.pred;
        if (curr.key == item){
          return false;
        }
        Node node = new Node(item);
        node.next = curr;
        pred.next = node;
        return true;
      }
      finally {
        curr.unlock();
      }
    }
    finally {
      pred.unlock();
    }
  }

  @Override
  public boolean removeInt(int item){
    head.lock();
    Node pred = head;
    Node curr = pred.next;
    try{
      curr.lock();
      try{
        Nodes nn = traverse(item, curr, pred);
        curr = nn.curr; pred = nn.pred;
        if (curr.key == item){
          pred.next = curr.next;
          return true;
        }
        return false;
      }
      finally {
        curr.unlock();
      }
    }
    finally {
      pred.unlock();
    }
  }

  @Override
  public boolean containsInt(int item){
    Node pred = head;
    Node curr = pred.next;

    while(curr.key < item){
      pred = curr;
      curr = pred.next;
    }
    return curr.key == item;
  }

  private class Node {
    Node(int item) {
      key = item;
      next = null;
    }

    public void lock(){
      l.lock();
    }
    public void unlock(){
      l.unlock();
    }
    public int key;
    public Node next;
    private Lock l = new ReentrantLock();
  }

  @Override
  public void clear() {
    head = new Node(Integer.MIN_VALUE);
    head.next = new Node(Integer.MAX_VALUE);
  }

  /**
   * Non atomic and thread-unsafe
   */
  @Override
  public int size() {
    int count = 0;

    Node curr = head.next;
    while (curr.key != Integer.MAX_VALUE) {
      curr = curr.next;
      count++;
    }
    return count;
  }
}