Eureka's timedsupersortask class (periodic task with automatic interval adjustment)

Welcome to visit mine GitHub

Here we classify and summarize all the original works of Xinchen ( Including supporting source code )：https://github.com/zq2599/blog_demos

cause

• One is based on Spring Cloud Application of framework , If registered to Eureka server, Then it will update the service list regularly , The code to start this scheduled task is in com.netflix.discovery.DiscoveryClient Class initScheduledTasks In the method , as follows （ From Engineering eureka-client, edition 1.7.0）：

private void initScheduledTasks() {		// Update service list         if (clientConfig.shouldFetchRegistry()) {            // registry cache refresh timer            int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();            int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();            scheduler.schedule(                    new TimedSupervisorTask(                            "cacheRefresh",                            scheduler,                            cacheRefreshExecutor,                            registryFetchIntervalSeconds,                            TimeUnit.SECONDS,                            expBackOffBound,                            new CacheRefreshThread()                    ),                    registryFetchIntervalSeconds, TimeUnit.SECONDS);        }		...		// Leave out the rest of the code 

• In the above code ,scheduler yes ScheduledExecutorService Interface implementation , Its schedule Methodical Official documents As shown below ：

• The red box above shows ： This method creates One time task , But in actual tests , If in CacheRefreshThread Class run Method , You will find that this method will be called periodically ;

• So the question arises ： Method schedule(Callable<V> callable,long delay,TimeUnit unit) The creation is clearly a One time task , but CacheRefreshThread By Periodic execution ;

To find the answer

• The open run Method source code , Please pay attention to the following Chinese Notes ：

public void run() {        Future future = null;        try {	    // Use Future, You can set the timeout for the child thread , In this way, the current thread does not have to wait infinitely             future = executor.submit(task);            threadPoolLevelGauge.set((long) executor.getActiveCount());            // Specifies the maximum time to wait for a child thread             future.get(timeoutMillis, TimeUnit.MILLISECONDS);  // block until done or timeout            //delay Is a very useful variable , We'll use that later , Remember here that every successful mission will delay Reset             delay.set(timeoutMillis);            threadPoolLevelGauge.set((long) executor.getActiveCount());        } catch (TimeoutException e) {            logger.error("task supervisor timed out", e);            timeoutCounter.increment();            long currentDelay = delay.get();            // When the task thread times out , Just put delay Double the variable , But it will not exceed the maximum delay time set during external call             long newDelay = Math.min(maxDelay, currentDelay * 2);            // Set to the latest value , Consider multithreading , So use the CAS            delay.compareAndSet(currentDelay, newDelay);        } catch (RejectedExecutionException e) {            // Once the blocking queue of the thread pool is full of pending tasks , A rejection policy was triggered , Will stop the scheduler             if (executor.isShutdown() || scheduler.isShutdown()) {                logger.warn("task supervisor shutting down, reject the task", e);            } else {                logger.error("task supervisor rejected the task", e);            }            rejectedCounter.increment();        } catch (Throwable e) {            // Once an unknown exception occurs , Stop the dispatcher             if (executor.isShutdown() || scheduler.isShutdown()) {                logger.warn("task supervisor shutting down, can't accept the task");            } else {                logger.error("task supervisor threw an exception", e);            }            throwableCounter.increment();        } finally {            // Here the mission is either done , Or something goes wrong , Use both cancel Methods to clean up tasks ;            if (future != null) {                future.cancel(true);            }            	    // As long as the scheduler doesn't stop , Then specify the waiting time and perform the same task again             if (!scheduler.isShutdown()) {            	// Here's the reason for periodic tasks ： As long as the scheduler is not stopped , Then create a one-time task , When the execution time is dealy Value ,            	// Suppose that the timeout passed in during an external call is 30 second （ Input parameters of construction method timeout）, The maximum interval time is 50 second ( Input parameters of construction method expBackOffBound)            	// If the last task did not time out , Then in 30 Start a new mission in seconds ,            	// If the last task timed out , Then in 50 Start a new mission in seconds （ There is a double operation in exception handling , Multiply by two 60 Seconds exceeded the maximum interval 50 second ）                scheduler.schedule(this, delay.get(), TimeUnit.MILLISECONDS);            }        }    }

• The truth is in the last line of code above ：scheduler.schedule(this, delay.get(), TimeUnit.MILLISECONDS)： After performing the task , Will call... Again schedule Method , Perform the same task after a specified time , This interval depends on whether the last task timed out , If it goes out of time, the interval will be larger ;

• Summary ： On the whole ,TimedSupervisorTask It's a periodic task at regular intervals , Once the timeout occurs, the interval time of the next cycle will be increased , If you continuously time out , So every time the interval is doubled , Until it reaches the upper limit set by the external parameters , Once the new task no longer times out , The interval time will automatically return to the initial value , And then there is CAS To control multithreading synchronization , Simple code , Ingenious design , It's worth learning ;

Welcome to Huawei cloud blog ： Xinchen, programmer

On the way to study , You are not alone , Xinchen's original works are accompanied all the way …