Cancel scheduled task for change count update when inactive

After at least 10 seconds of inactivity this will cancel
the ScheduledFuture for updating the change count service
property.  If later the change count is updated then a
new ScheduledFuture is submitted.

Author: tjwatson

scr/src/main/java/org/apache/felix/scr/impl/ComponentRegistry.java

@@ -31,8 +31,12 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.UnaryOperator;
 
 import org.apache.felix.scr.impl.inject.ComponentMethods;
 import org.apache.felix.scr.impl.inject.internal.ComponentMethodsImpl;
@@ -132,9 +136,12 @@ public class ComponentRegistry
 
     private final ScheduledExecutorService m_componentActor;
 
+    private final UpdateChangeCountProperty m_updateChangeCountPropertyTask;
+
     public ComponentRegistry(final ScrConfiguration scrConfiguration, final ScrLogger logger, final ScheduledExecutorService componentActor )
     {
         m_configuration = scrConfiguration;
+        m_updateChangeCountPropertyTask = new UpdateChangeCountProperty(m_configuration.serviceChangecountTimeout());
         m_logger = logger;
         m_componentActor = componentActor;
         m_componentHoldersByName = new HashMap<>();
@@ -716,44 +723,84 @@ public Dictionary<String, Object> getServiceRegistrationProperties()
 
     public void setRegistration(final ServiceRegistration<ServiceComponentRuntime> reg)
     {
-        long delay = m_configuration.serviceChangecountTimeout();
-        m_componentActor.scheduleWithFixedDelay(new UpdateChangeCountProperty(reg), delay, delay, TimeUnit.MILLISECONDS);
+        m_updateChangeCountPropertyTask.setRegistration(reg);
+        m_updateChangeCountPropertyTask.schedule();
     }
 
     class UpdateChangeCountProperty implements Runnable {
-        private final ServiceRegistration<ServiceComponentRuntime> registration;
+        private volatile ServiceRegistration<ServiceComponentRuntime> registration;
+        private final long maxNumberOfNoChanges;
+        private final long delay;
+
+        // guarded by this
+        private int noChangesCount = 0;
+        // guarded by this
+        private ScheduledFuture<?> scheduledFuture = null;
 
-        public UpdateChangeCountProperty(ServiceRegistration<ServiceComponentRuntime> registration)
+        public UpdateChangeCountProperty(long delay)
         {
-            this.registration = registration;
+            this.delay = delay;
+            // calculate the max number of no changes; must be at least 1 to avoid missing events
+            maxNumberOfNoChanges = Long.max(10000 / delay, 1);
+        }
+
+        public void setRegistration(ServiceRegistration<ServiceComponentRuntime> reg)
+        {
+            this.registration = reg;
+        }
+
+        public synchronized void schedule()
+        {
+            // reset noChangesCount to ensure task runs at least once more if it exists
+            noChangesCount = 0;
+            if (scheduledFuture != null) {
+                return;
+            }
+            scheduledFuture = m_componentActor.scheduleWithFixedDelay(this , delay, delay, TimeUnit.MILLISECONDS);
         }
 
         @Override
         public void run()
         {
+            ServiceRegistration<ServiceComponentRuntime> currentReg = registration;
+            if (currentReg == null) {
+                return;
+            }
             try {
-                Long registeredChangeCount = (Long) registration.getReference().getProperty(PROP_CHANGECOUNT);
+                Long registeredChangeCount = (Long) currentReg.getReference().getProperty(PROP_CHANGECOUNT);
                 if (registeredChangeCount == null || registeredChangeCount.longValue() != changeCount.get()) {
                     try
                     {
-                        registration.setProperties(getServiceRegistrationProperties());
+                        currentReg.setProperties(getServiceRegistrationProperties());
                     }
                     catch ( final IllegalStateException ise)
                     {
                         // we ignore this as this might happen on shutdown
                     }
+                } else {
+                    synchronized (this) {
+                        noChangesCount++;
+                        if (noChangesCount > maxNumberOfNoChanges) {
+                            // haven't had any changes for max number of tries;
+                            // cancel the scheduled future if it exists.
+                            if (scheduledFuture != null) {
+                                scheduledFuture.cancel(false);
+                                scheduledFuture = null;
+                            }
+                        }
+                    }
                 }
             } catch (Exception e) {
                 m_logger.log(Level.WARN,
                     "Service changecount update for {0} had a problem", e,
                     registration.getReference());
             }
         }
-
     }
 
     public void updateChangeCount()
     {
         this.changeCount.incrementAndGet();
+        m_updateChangeCountPropertyTask.schedule();
     }
 }