/**
  * Remove an element.
  *
  * @param item element to remove
  * @param msg
  * @return true if element was present
  */
 @Override
 public boolean remove(Integer item, String msg) {
   Node pred = null, curr = null;
   int key = item.hashCode();
   head.lock();
   try {
     pred = head;
     curr = pred.next;
     curr.lock();
     try {
       while (curr.key < key) {
         pred.unlock();
         pred = curr;
         curr = curr.next;
         curr.lock();
       }
       if (curr.key == key) {
         pred.next = curr.next;
         System.out.println(msg + "Removing : " + item);
         return true;
       }
       System.out.println(msg + "Removing " + item + " : Item not found.");
       return false;
     } finally {
       curr.unlock();
     }
   } finally {
     pred.unlock();
   }
 }
 /**
  * Remove an element.
  *
  * @param item element to remove
  * @param msg
  * @return true if element was present
  */
 @Override
 public boolean remove(Integer item, String msg) {
   int key = item.hashCode();
   while (true) {
     Node pred = this.head;
     Node curr = pred.next;
     while (curr.key < key) {
       pred = curr;
       curr = curr.next;
     }
     pred.lock();
     curr.lock();
     try {
       if (validate(pred, curr)) {
         if (curr.key == key) {
           pred.next = curr.next;
           System.out.println(msg + "Removing : " + item);
           return true;
         } else {
           System.out.println(msg + "Removing " + item + " : Item not found.");
           return false;
         }
       }
     } finally {
       pred.unlock();
       curr.unlock();
     }
   }
 }
 /**
  * Add an element.
  *
  * @param item element to add
  * @param msg
  * @return true if element was not there already
  */
 @Override
 public boolean add(Integer item, String msg) {
   int key = item.hashCode();
   head.lock();
   Node pred = head;
   try {
     Node curr = pred.next;
     curr.lock();
     try {
       while (curr.key < key) {
         pred.unlock();
         pred = curr;
         curr = curr.next;
         curr.lock();
       }
       if (curr.key == key) {
         System.out.println(msg + "Adding " + item + " : cannot add same item twice.");
         return false;
       }
       Node newNode = new Node(item);
       newNode.next = curr;
       pred.next = newNode;
       System.out.println(msg + "Adding : " + item);
       return true;
     } finally {
       curr.unlock();
     }
   } finally {
     pred.unlock();
   }
 }
 /**
  * Add an element.
  *
  * @param item element to add
  * @param msg
  * @return true if element was not there already
  */
 @Override
 public boolean add(Integer item, String msg) {
   int key = item.hashCode();
   while (true) {
     Node pred = this.head;
     Node curr = pred.next;
     while (curr.key <= key) {
       pred = curr;
       curr = curr.next;
     }
     pred.lock();
     curr.lock();
     try {
       if (validate(pred, curr)) {
         if (curr.key == key) {
           System.out.println(msg + "Adding " + item + " : cannot add same item twice.");
           return false;
         } else {
           Node entry = new Node(item);
           entry.next = curr;
           pred.next = entry;
           System.out.println(msg + "Adding : " + item);
           return true;
         }
       }
     } finally {
       pred.unlock();
       curr.unlock();
     }
   }
 }
Esempio n. 5
0
 public boolean remove(Object item) {
   Node pred = null, curr = null;
   int key = item.hashCode();
   head.lock();
   try {
     pred = head;
     curr = pred.next;
     curr.lock();
     try {
       while (curr.key < key) {
         pred.unlock();
         pred = curr;
         curr = curr.next;
         curr.lock();
       }
       if (curr.key == key) {
         pred.next = curr.next;
         return true;
       }
       return false;
     } finally {
       curr.unlock();
     }
   } finally {
     pred.unlock();
   }
 }
Esempio n. 6
0
 public boolean insert(Object item) {
   int key = item.hashCode();
   head.lock();
   Node pred = head;
   try {
     Node curr = pred.next;
     curr.lock();
     try {
       while (curr.key < key) {
         pred.unlock();
         pred = curr;
         curr = curr.next;
         curr.lock();
       }
       if (curr.key == key) {
         return false;
       }
       Node newNode = new Node(item);
       newNode.next = curr;
       pred.next = newNode;
       return true;
     } finally {
       curr.unlock();
     }
   } finally {
     pred.unlock();
   }
 }
 /**
  * Test whether element is present
  *
  * @param item element to test
  * @return true if element is present
  */
 @Override
 public boolean contains(Integer item) {
   int key = item.hashCode();
   while (true) {
     Node pred = this.head;
     Node curr = pred.next;
     while (curr.key < key) {
       pred = curr;
       curr = curr.next;
     }
     try {
       pred.lock();
       curr.lock();
       if (validate(pred, curr)) {
         return (curr.key == key);
       }
     } finally {
       pred.unlock();
       curr.unlock();
     }
   }
 }
Esempio n. 8
0
 public boolean contains(Object item) {
   Node last = null, pred = null, curr = null;
   int key = item.hashCode();
   head.lock();
   try {
     pred = head;
     curr = pred.next;
     curr.lock();
     try {
       while (curr.key < key) {
         pred.unlock();
         pred = curr;
         curr = curr.next;
         curr.lock();
       }
       return (curr.key == key);
     } finally {
       curr.unlock();
     }
   } finally {
     pred.unlock();
   }
 }