SubscriptionList to use j.u.c.Lock

Author: akarnokd

src/main/java/rx/internal/util/SubscriptionList.java

@@ -20,9 +20,10 @@
 import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.concurrent.locks.ReentrantLock;
 
 import rx.Subscription;
-import rx.exceptions.*;
+import rx.exceptions.Exceptions;
 
 /**
  * Subscription that represents a group of Subscriptions that are unsubscribed together.
@@ -33,6 +34,7 @@ public final class SubscriptionList implements Subscription {
 
     private LinkedList<Subscription> subscriptions;
     private volatile boolean unsubscribed;
+    private final ReentrantLock lock = new ReentrantLock();
 
     public SubscriptionList() {
     }
@@ -64,14 +66,19 @@ public void add(final Subscription s) {
             return;
         }
         if (!unsubscribed) {
-            synchronized (this) {
+            lock.lock();
+            try {
                 if (!unsubscribed) {
-                    if (subscriptions == null) {
-                        subscriptions = new LinkedList<Subscription>();
+                    LinkedList<Subscription> subs = subscriptions;
+                    if (subs == null) {
+                        subs = new LinkedList<Subscription>();
+                        subscriptions = subs;
                     }
-                    subscriptions.add(s);
+                    subs.add(s);
                     return;
                 }
+            } finally {
+                lock.unlock();
             }
         }
         // call after leaving the synchronized block so we're not holding a lock while executing this
@@ -81,11 +88,15 @@ public void add(final Subscription s) {
     public void remove(final Subscription s) {
         if (!unsubscribed) {
             boolean unsubscribe = false;
-            synchronized (this) {
-                if (unsubscribed || subscriptions == null) {
+            lock.lock();
+            try {
+                LinkedList<Subscription> subs = subscriptions;
+                if (unsubscribed || subs == null) {
                     return;
                 }
-                unsubscribe = subscriptions.remove(s);
+                unsubscribe = subs.remove(s);
+            } finally {
+                lock.unlock();
             }
             if (unsubscribe) {
                 // if we removed successfully we then need to call unsubscribe on it (outside of the lock)
@@ -102,13 +113,16 @@ public void remove(final Subscription s) {
     public void unsubscribe() {
         if (!unsubscribed) {
             List<Subscription> list;
-            synchronized (this) {
+            lock.lock();
+            try {
                 if (unsubscribed) {
                     return;
                 }
                 unsubscribed = true;
                 list = subscriptions;
                 subscriptions = null;
+            } finally {
+                lock.unlock();
             }
             // we will only get here once
             unsubscribeFromAll(list);
@@ -136,9 +150,12 @@ private static void unsubscribeFromAll(Collection<Subscription> subscriptions) {
     public void clear() {
         if (!unsubscribed) {
             List<Subscription> list;
-            synchronized (this) {
+            lock.lock();
+            try {
                 list = subscriptions;
                 subscriptions = null;
+            } finally {
+                lock.unlock();
             }
             unsubscribeFromAll(list);
         }
@@ -149,8 +166,11 @@ public void clear() {
      */
     public boolean hasSubscriptions() {
         if (!unsubscribed) {
-            synchronized (this) {
+            lock.lock();
+            try {
                 return !unsubscribed && subscriptions != null && !subscriptions.isEmpty();
+            } finally {
+                lock.unlock();
             }
         }
         return false;