complete project1 with ReentrantLock and ReadWriteLock

Author: FrauBoes

ConcurrentProg/miniproject_1/src/main/java/edu/coursera/concurrent/CoarseLists.java

@@ -1,5 +1,8 @@
 package edu.coursera.concurrent;
 
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
 /**
  * Wrapper class for two lock-based concurrent list implementations.
  */
@@ -26,6 +29,9 @@ public static final class CoarseList extends ListSet {
         public CoarseList() {
             super();
         }
+        
+        // Invoke a lock that is used in all thread-safe methods
+        private final ReentrantLock lock = new ReentrantLock();
 
         /**
          * {@inheritDoc}
@@ -34,22 +40,28 @@ public CoarseList() {
          */
         @Override
         boolean add(final Integer object) {
-            Entry pred = this.head;
-            Entry curr = pred.next;
-
-            while (curr.object.compareTo(object) < 0) {
-                pred = curr;
-                curr = curr.next;
-            }
-
-            if (object.equals(curr.object)) {
-                return false;
-            } else {
-                final Entry entry = new Entry(object);
-                entry.next = curr;
-                pred.next = entry;
-                return true;
-            }
+        	try {
+            	lock.lock();
+
+	            Entry pred = this.head;
+	            Entry curr = pred.next;
+	
+	            while (curr.object.compareTo(object) < 0) {
+	                pred = curr;
+	                curr = curr.next;
+	            }
+	
+	            if (object.equals(curr.object)) {
+	                return false;
+	            } else {
+	                final Entry entry = new Entry(object);
+	                entry.next = curr;
+	                pred.next = entry;
+	                return true;
+	            }
+        	} finally {
+        		lock.unlock();
+        	}
         }
 
         /**
@@ -59,20 +71,26 @@ boolean add(final Integer object) {
          */
         @Override
         boolean remove(final Integer object) {
-            Entry pred = this.head;
-            Entry curr = pred.next;
-
-            while (curr.object.compareTo(object) < 0) {
-                pred = curr;
-                curr = curr.next;
-            }
-
-            if (object.equals(curr.object)) {
-                pred.next = curr.next;
-                return true;
-            } else {
-                return false;
-            }
+        	try {
+        		lock.lock();
+       
+	            Entry pred = this.head;
+	            Entry curr = pred.next;
+	
+	            while (curr.object.compareTo(object) < 0) {
+	                pred = curr;
+	                curr = curr.next;
+	            }
+	
+	            if (object.equals(curr.object)) {
+	                pred.next = curr.next;
+	                return true;
+	            } else {
+	                return false;
+	            }
+        	} finally {
+        		lock.unlock();
+        	}
         }
 
         /**
@@ -82,6 +100,9 @@ boolean remove(final Integer object) {
          */
         @Override
         boolean contains(final Integer object) {
+        	try {
+        		lock.lock();
+        	
             Entry pred = this.head;
             Entry curr = pred.next;
 
@@ -90,6 +111,10 @@ boolean contains(final Integer object) {
                 curr = curr.next;
             }
             return object.equals(curr.object);
+        	
+        	} finally {
+        		lock.unlock();
+        	}
         }
     }
 
@@ -116,6 +141,9 @@ public static final class RWCoarseList extends ListSet {
         public RWCoarseList() {
             super();
         }
+        
+        // Instantiate ReadWriteLock that is used in all thread-safe methods
+        private final ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();
 
         /**
          * {@inheritDoc}
@@ -124,22 +152,28 @@ public RWCoarseList() {
          */
         @Override
         boolean add(final Integer object) {
-            Entry pred = this.head;
-            Entry curr = pred.next;
-
-            while (curr.object.compareTo(object) < 0) {
-                pred = curr;
-                curr = curr.next;
-            }
-
-            if (object.equals(curr.object)) {
-                return false;
-            } else {
-                final Entry entry = new Entry(object);
-                entry.next = curr;
-                pred.next = entry;
-                return true;
-            }
+        	try { 
+        		rwlock.writeLock().lock();
+        		
+	            Entry pred = this.head;
+	            Entry curr = pred.next;
+	            
+	            while (curr.object.compareTo(object) < 0) {
+	                pred = curr;
+	                curr = curr.next;
+	            }
+	
+	            if (object.equals(curr.object)) {
+	                return false;
+	            } else {
+	                final Entry entry = new Entry(object);
+	                entry.next = curr;
+	                pred.next = entry;
+	                return true;
+	            }
+        	} finally {
+        		rwlock.writeLock().unlock();
+        	}    
         }
 
         /**
@@ -149,20 +183,26 @@ boolean add(final Integer object) {
          */
         @Override
         boolean remove(final Integer object) {
-            Entry pred = this.head;
-            Entry curr = pred.next;
-
-            while (curr.object.compareTo(object) < 0) {
-                pred = curr;
-                curr = curr.next;
-            }
-
-            if (object.equals(curr.object)) {
-                pred.next = curr.next;
-                return true;
-            } else {
-                return false;
-            }
+        	try {
+        		rwlock.writeLock().lock();
+
+	            Entry pred = this.head;
+	            Entry curr = pred.next;
+	
+	            while (curr.object.compareTo(object) < 0) {
+	                pred = curr;
+	                curr = curr.next;
+	            }
+	
+	            if (object.equals(curr.object)) {
+	                pred.next = curr.next;
+	                return true;
+	            } else {
+	                return false;
+	            }
+        	} finally {
+        		rwlock.writeLock().unlock();
+        	}
         }
 
         /**
@@ -172,14 +212,20 @@ boolean remove(final Integer object) {
          */
         @Override
         boolean contains(final Integer object) {
-            Entry pred = this.head;
-            Entry curr = pred.next;
-
-            while (curr.object.compareTo(object) < 0) {
-                pred = curr;
-                curr = curr.next;
-            }
-            return object.equals(curr.object);
+        	try {
+        		rwlock.readLock().lock();
+        		
+        		Entry pred = this.head;
+                Entry curr = pred.next;
+
+                while (curr.object.compareTo(object) < 0) {
+                    pred = curr;
+                    curr = curr.next;
+                }
+                return object.equals(curr.object);
+        	} finally {
+        		rwlock.readLock().unlock();
+        	} 
         }
     }
 }