This method is used only by default cache provider (cache.java). Do nothing.
187020
@Override
    public void addToTimeLimitDaemon(Object id, long expirationTime, int inactivity) {
        final String methodName = "addToTimeLimitDaemon()";
        if (tc.isDebugEnabled()) {
            Tr.debug(tc, methodName + " cacheName=" + cacheName + " ERROR because it should not be called");
        }
    }
93205
protected static synchronized void initCache() {
        if (m_Cache == null) {
            m_Cache = new ClassCache();
            // failed to locate any classes on the classpath, maybe inside Weka?
            // try loading fixed list of classes
            if (m_Cache.isEmpty()) {
                InputStream inputStream = null;
                try {
                    inputStream = m_Cache.getClass().getResourceAsStream(CLASS_LIST);
                    m_Cache = new ClassCache(new FixedClassListTraversal(inputStream));
                }
                catch (Exception e) {
                    System.err.println("Failed to initialize class cache from fixed list (" + CLASS_LIST + ")!");
                    e.printStackTrace();
                }
                finally {
                    if (inputStream != null) {
                        try {
                            inputStream.close();
                        }
                        catch (Exception e) {
                            // ignored
                        }
                    }
                }
            }
        }
    }
490090
protected void pruneCache() {
        final long expired = System.currentTimeMillis() - timeToLive;
        this.cacheMap.values().removeIf(entry -> entry.createTime < expired);
    }
1140391
public synchronized void stop() {
        for (final AttributeCache cache : attributeCacheMap.values()) {
            cache.stopRefresh();
        }
        for (final CommandCache cache : commandCacheMap.values()) {
            cache.stopRefresh();
        }
        if (stateCache != null) {
            stateCache.stopRefresh();
        }
        if (statusCache != null) {
            statusCache.stopRefresh();
        }
        if (POLLING_POOL != null) {
            POLLING_POOL.shutdownNow();
            POLLING_POOL = new ScheduledThreadPoolExecutor(poolSize, new TangoCacheThreadFactory());
        }
    }
746341
public static void clearJarCache()
  {
    LruCache<PathImpl,Jar> jarCache = _jarCache;
    
    if (jarCache == null)
      return;

    ArrayList<Jar> jars = new ArrayList<Jar>();
    
    synchronized (jarCache) {
      Iterator<Jar> iter = jarCache.values();
      
      while (iter.hasNext())
        jars.add(iter.next());
    }

    for (int i = 0; i < jars.size(); i++) {
      Jar jar = jars.get(i);
        
      if (jar != null)
        jar.clearCache();
    }
  }
1062601
public void resetInsideClassCache() {
    final Map<Class<?>, Field[]> fieldz = cachedClasses;
    if (fieldz != null) {
      synchronized (fieldz) {
        fieldz.clear();
      }
    }
  }
15255
public synchronized void setCache(RemoteListCache cache) {
		if (cache != null && (this.cache == null || !this.cache.isComplete())) {
			this.cache = cache;
		}
	}
1051431
public void free()
    {
        m_bookmark = null;
        m_objectID = null;
        m_dataSource = null;
        m_objectSource = null;
        if (m_buffer != null)
        {
            m_buffer.free();
            m_buffer = null;
        } 
    }
399334
private static void deleteCache(Configuration conf,
      MRAsyncDiskService asyncDiskService) throws IOException {
    List<CacheStatus> deleteSet = new LinkedList<CacheStatus>();
    // try deleting cache Status with refcount of zero
    synchronized (cachedArchives) {
      for (Iterator<String> it = cachedArchives.keySet().iterator();
           it.hasNext();) {
        String cacheId = (String) it.next();
        CacheStatus lcacheStatus = cachedArchives.get(cacheId);
        if (lcacheStatus.refcount == 0) {
          // delete this cache entry from the global list
          // and mark the localized file for deletion
          deleteSet.add(lcacheStatus);
          it.remove();
        }
      }
    }
    // do the deletion asynchronously, after releasing the global lock
    Thread cacheFileCleaner = new Thread(
        new CacheFileCleanTask(asyncDiskService,
                               FileSystem.getLocal(conf),
                               deleteSet));
    cacheFileCleaner.start();
  }
1052284
protected void sweepCache() {
        for (Iterator keyIterator = keySet().iterator(); keyIterator.hasNext(); ) {
            Object key = keyIterator.next();
            ValueWrapper valueWrapper = (ValueWrapper) super.get(key);
            long creationTime = valueWrapper.getCreationTime();
            long cacheInterval = valueWrapper.getCacheInterval();
            long currentTime = System.currentTimeMillis();
            if (cacheInterval >= 0 && creationTime + cacheInterval < currentTime) {
                remove(key);
            }
        }
    }
447324
@Override
    public void destroy() {
        try {
            super.destroy();
        } finally {
            if (myOwnKafkaClient && defaultKafkaClient != null) {
                try {
                    defaultKafkaClient.destroy();
                } catch (Exception e) {
                    LOGGER.warn(e.getMessage(), e);
                } finally {
                    defaultKafkaClient = null;
                }
            }
        }
    }
1354425
public static <T extends BaseEntity> void removeCache(T bean){
		if(CacheHandler.cacheProvider == null)return;
		String key = buildCacheKey(bean.getClass(), bean.getId());
		CacheHandler.cacheProvider.remove(key);
	}
616320
protected void putToCache(String cacheName, String key, Object value) {
        putToCache(cacheName, key, value, 0);
    }
662280
@Nonnull
  public TypeaheadRemote setCache (@Nonnull final ETriState eCache)
  {
    m_eCache = ValueEnforcer.notNull (eCache, "Cache");
    return this;
  }
398378
private void initCacheSyncTask(){
        int delay = getServiceDirectoryConfig().getInt(
                SD_API_CACHE_SYNC_DELAY_PROPERTY,
                SD_API_CACHE_SYNC_DELAY_DEFAULT);
        int interval = getServiceDirectoryConfig().getInt(
                SD_API_CACHE_SYNC_INTERVAL_PROPERTY,
                SD_API_CACHE_SYNC_INTERVAL_DEFAULT);

        syncService.scheduleWithFixedDelay(new CacheSyncTask(),
                delay, interval, TimeUnit.SECONDS);
    }
404942
@Nonnull
  public final UnifiedResponse disableCaching ()
  {
    // Remove any eventually set headers
    removeCaching ();

    if (m_eHttpVersion.is10 ())
    {
      // Set to expire far in the past for HTTP/1.0.
      m_aResponseHeaderMap.setHeader (CHttpHeader.EXPIRES, ResponseHelperSettings.EXPIRES_NEVER_STRING);

      // Set standard HTTP/1.0 no-cache header.
      m_aResponseHeaderMap.setHeader (CHttpHeader.PRAGMA, "no-cache");
    }
    else
    {
      final CacheControlBuilder aCacheControlBuilder = new CacheControlBuilder ().setNoStore (true)
                                                                                 .setNoCache (true)
                                                                                 .setMustRevalidate (true)
                                                                                 .setProxyRevalidate (true);

      // Set IE extended HTTP/1.1 no-cache headers.
      // http://aspnetresources.com/blog/cache_control_extensions
      // Disabled because:
      // http://blogs.msdn.com/b/ieinternals/archive/2009/07/20/using-post_2d00_check-and-pre_2d00_check-cache-directives.aspx
      if (false)
        aCacheControlBuilder.addExtension ("post-check=0").addExtension ("pre-check=0");

      setCacheControl (aCacheControlBuilder);
    }
    return this;
  }
342955
def disable_caching(self):
        ""
        self.caching_enabled = False
        for c in self.values():
            c.disable_cacher()