Merge pull request ReactiveX#2912 from akarnokd/FixEventLoopsPerfDegradation

Fix the performance degradation due to different schedule execution and

Author: benjchristensen

src/main/java/rx/internal/schedulers/EventLoopsScheduler.java

@@ -117,10 +117,7 @@ public Subscription schedule(Action0 action) {
             if (isUnsubscribed()) {
                 return Subscriptions.unsubscribed();
             }
-            ScheduledAction s = poolWorker.scheduleActual(action, 0, null);
-            
-            serial.add(s);
-            s.addParent(serial);
+            ScheduledAction s = poolWorker.scheduleActual(action, 0, null, serial);
 
             return s;
         }

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

@@ -15,12 +15,7 @@
  */
 package rx.internal.util;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.concurrent.locks.ReentrantLock;
+import java.util.*;
 
 import rx.Subscription;
 import rx.exceptions.Exceptions;
@@ -34,7 +29,6 @@ public final class SubscriptionList implements Subscription {
 
     private LinkedList<Subscription> subscriptions;
     private volatile boolean unsubscribed;
-    private final ReentrantLock lock = new ReentrantLock();
 
     public SubscriptionList() {
     }
@@ -66,8 +60,7 @@ public void add(final Subscription s) {
             return;
         }
         if (!unsubscribed) {
-            lock.lock();
-            try {
+            synchronized (this) {
                 if (!unsubscribed) {
                     LinkedList<Subscription> subs = subscriptions;
                     if (subs == null) {
@@ -77,8 +70,6 @@ public void add(final Subscription s) {
                     subs.add(s);
                     return;
                 }
-            } finally {
-                lock.unlock();
             }
         }
         // call after leaving the synchronized block so we're not holding a lock while executing this
@@ -88,15 +79,12 @@ public void add(final Subscription s) {
     public void remove(final Subscription s) {
         if (!unsubscribed) {
             boolean unsubscribe = false;
-            lock.lock();
-            try {
+            synchronized (this) {
                 LinkedList<Subscription> subs = subscriptions;
                 if (unsubscribed || subs == null) {
                     return;
                 }
                 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)
@@ -113,16 +101,13 @@ public void remove(final Subscription s) {
     public void unsubscribe() {
         if (!unsubscribed) {
             List<Subscription> list;
-            lock.lock();
-            try {
+            synchronized (this) {
                 if (unsubscribed) {
                     return;
                 }
                 unsubscribed = true;
                 list = subscriptions;
                 subscriptions = null;
-            } finally {
-                lock.unlock();
             }
             // we will only get here once
             unsubscribeFromAll(list);
@@ -150,12 +135,9 @@ private static void unsubscribeFromAll(Collection<Subscription> subscriptions) {
     public void clear() {
         if (!unsubscribed) {
             List<Subscription> list;
-            lock.lock();
-            try {
+            synchronized (this) {
                 list = subscriptions;
                 subscriptions = null;
-            } finally {
-                lock.unlock();
             }
             unsubscribeFromAll(list);
         }
@@ -166,11 +148,8 @@ public void clear() {
      */
     public boolean hasSubscriptions() {
         if (!unsubscribed) {
-            lock.lock();
-            try {
+            synchronized (this) {
                 return !unsubscribed && subscriptions != null && !subscriptions.isEmpty();
-            } finally {
-                lock.unlock();
             }
         }
         return false;