This method initialises the refresh cycle.
197536
protected void initRefreshCycle() {
        // Check if should check for updates
        Integer refresh = PropertyUtil.getPropertyAsInteger(PropertyUtil.HAWKULAR_APM_CONFIG_REFRESH);

        if (log.isLoggable(Level.FINER)) {
            log.finer("Configuration refresh cycle (in seconds) = " + refresh);
        }

        if (refresh != null) {
            Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
                public Thread newThread(Runnable r) {
                    Thread t = Executors.defaultThreadFactory().newThread(r);
                    t.setDaemon(true);
                    return t;
                }
            }).scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        Map<String, TransactionConfig> changed = configurationService.getTransactions(null,
                                configLastUpdated);

                        for (Map.Entry<String, TransactionConfig> stringBusinessTxnConfigEntry : changed.entrySet()) {
                            TransactionConfig btc = stringBusinessTxnConfigEntry.getValue();

                            if (btc.isDeleted()) {
                                if (log.isLoggable(Level.FINER)) {
                                    log.finer("Removing config for btxn '" + stringBusinessTxnConfigEntry.getKey() + "' = " + btc);
                                }

                                filterManager.remove(stringBusinessTxnConfigEntry.getKey());
                                processorManager.remove(stringBusinessTxnConfigEntry.getKey());
                            } else {
                                if (log.isLoggable(Level.FINER)) {
                                    log.finer("Changed config for btxn '" + stringBusinessTxnConfigEntry.getKey() + "' = " + btc);
                                }

                                filterManager.init(stringBusinessTxnConfigEntry.getKey(), btc);
                                processorManager.init(stringBusinessTxnConfigEntry.getKey(), btc);
                            }

                            if (btc.getLastUpdated() > configLastUpdated) {
                                configLastUpdated = btc.getLastUpdated();
                            }
                        }
                    } catch (Exception e) {
                        log.log(Level.SEVERE, "Failed to update transaction configuration", e);
                    }
                }
            }, refresh.intValue(), refresh.intValue(), TimeUnit.SECONDS);
        }
    }
204126
private void init() {
    ServerSideServerStore serverStore = ehcacheStateService.getStore(storeIdentifier);
    ServerStoreBinding serverStoreBinding = new ServerStoreBinding(storeIdentifier, serverStore);
    CompletableFuture<Void> r1 = managementRegistry.register(serverStoreBinding);
    ServerSideConfiguration.Pool pool = ehcacheStateService.getDedicatedResourcePool(storeIdentifier);
    CompletableFuture<Void> allOf;
    if (pool != null) {
      allOf = CompletableFuture.allOf(r1, managementRegistry.register(new PoolBinding(storeIdentifier, pool, PoolBinding.AllocationType.DEDICATED)));
    } else {
      allOf = r1;
    }
    allOf.thenRun(() -> {
      managementRegistry.refresh();
      managementRegistry.pushServerEntityNotification(serverStoreBinding, EHCACHE_SERVER_STORE_CREATED.name());
    });
  }
1212464
private void refreshId()
	{
		if (null == getName())
		{
			setId(null);
		}
		else
		{
			if (null == getIdSuffix())
			{
				setId(getName());
			}
			else
			{
				setId(getName() + getIdSuffix());
			}
		}
	}
69755
public function refresh()
    {
      $this->create(PhoneCombo::Make(new PhoneNumber($this->from), new PhoneNumber($this->to)));
    }
1174723
public void initialize() {
        try {
            writeLock.lock();
            if (!isInitialized()) {
                super.initialize();
                setInitialized(true);
                this.initCalled = true;
            }
        } finally {
            // downgrade to readlock before releasing just in case
            readLock.lock();
            writeLock.unlock();
            readLock.unlock();
        }
    }
444536
function() {

		if (Lava.Core.isProcessingEvent()) {
			Lava.logError("ViewManager::refresh() must not be called inside event listeners");
			return;
		}

		if (this._is_refreshing) {
			Lava.logError("ViewManager: recursive call to refresh()");
			return;
		}

		Lava.ScopeManager.refresh();

		if (this._dirty_views.length) {

			this._is_refreshing = true;
			Lava.ScopeManager.lock();
			this._refresh_id++;

			do {
				var dirty_views = this._dirty_views,
					has_exceptions;
				this._dirty_views = [];
				has_exceptions = this._refreshCycle(dirty_views);
			} while (this._dirty_views.length && !has_exceptions);

			Lava.ScopeManager.unlock();
			this._is_refreshing = false;

		}

	}
772396
def refresh(self):
        """"""
        if self._source_tree.cache_is_stale():
            self._source_tree.refresh()
            logging.info('Refreshing object tree')
            self._init_cache()
            self.sync_cache_with_source_tree()
503997
public void refresh() {
		if (logger.isDebugEnabled()) {
			logger.debug("Refreshing held value '"
					+ StylerUtils.style(super.getValue()) + "'");
		}
		setValue(refreshFunction.call(null));
	}
511921
@Override
    public void refresh() {
        // do nothing
        org.grails.io.support.Resource descriptor = getDescriptor();
        if (grailsApplication == null || descriptor == null) {
            return;
        }

        ClassLoader parent = grailsApplication.getClassLoader();
        GroovyClassLoader gcl = new GroovyClassLoader(parent);
        try {
            initialisePlugin(gcl.parseClass(descriptor.getFile()));
        } catch (Exception e) {
            LOG.error("Error refreshing plugin: " + e.getMessage(), e);
        }
    }
1257245
private void enableRefresh() {
        this.refreshButton.setEnabled(true);
        this.autoRefreshLabel.setEnabled(true);
        this.autoRefreshComboBox.setEnabled(true);
        updateAutoRefreshTimer();
    }
32794
@Override
	public synchronized void refresh() {
	
		IntervalProperty[] properties = getProperties();
		
		for(IntervalProperty p : properties ) {
			
			p.refresh();
		}
		
	}
719315
def initialize(self):
        
        self.time.update(self.components.initial_time())
        self.time.stage = 'Initialization'
        super(Model, self).initialize()
322056
function _setRefreshTime() 
    {
        if (is_null($this->_lifeTime)) {
            $this->_refreshTime = null;
        } else {
            $this->_refreshTime = time() - $this->_lifeTime;
        }
    }
125840
public synchronized void refresh() {
        try {
            AmazonInfo newInfo = getNewAmazonInfo();

            if (shouldUpdate(newInfo, info)) {
                // the datacenter info has changed, re-sync it
                logger.info("The AmazonInfo changed from : {} => {}", info, newInfo);
                this.info = newInfo;
            }
        } catch (Throwable t) {
            logger.error("Cannot refresh the Amazon Info ", t);
        }
    }
989283
def refresh
      @win.refresh
      children.each { |c|
        c.refresh
      }

      component.component.screen.refresh if cdk?
    end
800620
public void initialize() {

        OpenCms.getExecutor().scheduleWithFixedDelay(new Runnable() {

            public void run() {

                checkForUpdates();
            }
        }, DELAY_MILLIS, DELAY_MILLIS, TimeUnit.MILLISECONDS);
        reload();
    }
559325
public function refresh()
    {
        $this->removeCache();
        $event = $this->eventManager->dispatch('refresh_cache', 'RefreshCache');
        $this->writeCache($event->getParameters());
    }