Refresh syncers state

@param {string|string[]} [keys] - Syncers to refresh
769555
function refreshSyncers(keys) {
	if (typeof keys === 'string') {
		keys = [keys]
	}
	if (!keys) {
		keys = Object.keys(this._syncers)
	}
	return Promise.all(keys.map(key => {
		return this._syncers[key].refresh()
	}))
}
707689
function updateKeys() {
      keys = [];

      for (var key in items) {
        keys.push(key);
      }

      LocalStorage.length = keys.length;
    }
599451
protected void init(Class<T> cls, Key ... keys) {
        readDataSource = Execution.getDataSourceName(cls.getName(), true);
        writeDataSource = Execution.getDataSourceName(cls.getName(), false);
        if( readDataSource == null ) {
            readDataSource = writeDataSource;
        }
        if( writeDataSource == null ) {
            writeDataSource = readDataSource;
        }
        
        if (keys != null && keys.length > 0) {
        	
        	secondaryCache = new ConcurrentHashMap<String,ConcurrentHashMap<String,T>>(keys.length);
        	for (Key k : keys) {
        		secondaryCache.put(k.toString(), new ConcurrentHashMap<String,T>(0));
        	}
        }
    }
1056444
def mget(msg_id, keys)
      keys = keys.map{|suffix| key(msg_id, suffix)}
      with_failover { redis.mget(*keys) }
    end
368570
private void removeUnloadableKeys(Collection<Data> keys) {
        if (keys == null || keys.isEmpty()) {
            return;
        }
        keys.removeIf(key -> !mapDataStore.loadable(key));
    }
1179847
@Override
  public void resync() {
    lock.writeLock().lock();
    try {
      if (this.knownObjects == null) {
        return;
      }

      List<String> keys = this.knownObjects.listKeys();
      for (String key : keys) {
        syncKeyLocked(key);
      }
    } finally {
      lock.writeLock().unlock();
    }
  }
555738
function backgroundRefresh(){
    for(key in refreshKeys){
      if(refreshKeys.hasOwnProperty(key)){
        var data = refreshKeys[key];
        if(data.expiration - Date.now() < self.backgroundRefreshMinTtl){
          data.refresh(key, function (err, response){
            if(!err){
              self.set(key, response, data.lifeSpan, data.refresh, noop);
            }
          });
        }
      }
    }
  }
550769
function(keys) {
    var missingRelations = [];
    var relationKeys = this.relationDefinitions ? Object.keys(this.relationDefinitions) : [];
    _.each(keys, function(key) {
      var isRelation = relationKeys.indexOf(key) > -1;
      if (isRelation && _.isUndefined(this.get(key))) {
        missingRelations.push(key);
      }
    }, this);
    return _.uniq(missingRelations);
  }
438603
public void invalidate(Key... keys) {
        for (Key key : keys) {
            logger.debug("Invalidating the response cache key : {} {} {} {}, {}",
                    key.getEntityType(), key.getName(), key.getVersion(), key.getType(), key.getEurekaAccept());

            readWriteCacheMap.invalidate(key);
            Collection<Key> keysWithRegions = regionSpecificKeys.get(key);
            if (null != keysWithRegions && !keysWithRegions.isEmpty()) {
                for (Key keysWithRegion : keysWithRegions) {
                    logger.debug("Invalidating the response cache key : {} {} {} {} {}",
                            key.getEntityType(), key.getName(), key.getVersion(), key.getType(), key.getEurekaAccept());
                    readWriteCacheMap.invalidate(keysWithRegion);
                }
            }
        }
    }
408905
public void updateMethodKey() {
        Arrays.stream(ParamType.values()).forEach(paramType -> this.syncMethodKey(paramType));

        this.validationDataRepository.flush();
        this.validationStore.refresh();
        log.info("[METHOD_KEY_SYNC] Complete");
    }
741089
def matchers_refresh(self):
        '''
        
        '''
        log.debug('Refreshing matchers.')
        self.matchers = salt.loader.matchers(self.opts)
430589
private void loadAllAndReplaceExisting(Set<? extends K> keys) {
    int[] ignored = { 0 };
    Map<K, V> loaded = cacheLoader.get().loadAll(keys);
    for (Map.Entry<? extends K, ? extends V> entry : loaded.entrySet()) {
      putNoCopyOrAwait(entry.getKey(), entry.getValue(), /* publishToWriter */ false, ignored);
    }
  }
930573
@Override
    public CompletableFuture<V> getAndRefreshAsync(String key, int expireSeconds) {
        return (CompletableFuture) refreshAsync(key, expireSeconds).thenCompose(v -> getAsync(key));
    }
791234
public function reset(array $keys)
    {
        foreach ($keys as $key) {
            $this->getSettingOrFail($key);
        }

        $this->backend->removeSettings($keys);
    }
16153
def []=(key, value)
      @lock.synchronize do
        @indexes = {}
        if value.id_changed?
          hash.delete value.to_id(true)
        end
        saved = hash[key] = value.to_hash.freeze
        adapter.save_database if @options[:sync]
        saved
      end
    end
814540
function remove(keys) {
  var self = this

  if (typeof keys === 'string') {
    self.map[keys] = undefined
  } else {
    removeAll(self.map, keys)
  }

  return self
}
1081715
function update (key, value) {
  if (Array.isArray(key)) {
    return AsyncStorage.multiMerge(key.map(([key, val]) => [key, JSON.stringify(val)]))
  }

  return AsyncStorage.mergeItem(key, JSON.stringify(value))
}