Removes a value from the cache by its key.

@param correlationId (optional) transaction id to trace execution through
call chain.
@param key           a unique value key.
505466
public void remove(String correlationId, String key) {
		synchronized (_lock) {
			// Get the entry
			CacheEntry entry = _cache.get(key);

			// Remove entry from the cache
			if (entry != null) {
				_cache.remove(key);
				_count--;
			}
		}
	}
1306779
private void cacheEntryRemoved(String key, T value)
    {
        InfinispanCacheEntryEvent<T> event =
            new InfinispanCacheEntryEvent<>(new InfinispanCacheEntry<T>(this, key, value));

        sendEntryRemovedEvent(event);
    }
232909
public void removeProp(String key) {
    this.specProperties.remove(key);
    if (this.commonProperties.containsKey(key)) {
      // This case should not happen.
      Properties commonPropsCopy = new Properties();
      commonPropsCopy.putAll(this.commonProperties);
      commonPropsCopy.remove(key);
      this.commonProperties = commonPropsCopy;
    }
  }
678735
public void remove(K key) {

        V removedValue = m_forwardMap.remove(key);
        if (removedValue != null) {
            m_reverseMap.remove(removedValue, key);
        }
    }
944906
public void clear(Object key) {
		Object removed;
		if (isCachingEnabled()) {
			synchronized (mirror) {
				synchronized (data) {
					removed = data.remove(key);
					mirror.remove(key);
				}
			}
			System.out.println(new LogEntry("object with key " + key + (removed == null ? " NOT" : "") + " removed from cache"));
		}
	}
645156
private void removeAllRelatedFromCache(String groupId)
   {
      cache.remove(CacheHandler.GROUP_PREFIX + groupId, CacheType.MEMBERSHIP);
   }
1043876
protected void removeFromCache(String cacheName, String key) {
        try {
            ICache cache = getCache(cacheName);
            if (cache != null) {
                cache.delete(key);
            }
        } catch (CacheException e) {
            LOGGER.warn(e.getMessage(), e);
        }
    }
1222930
public synchronized boolean remove(final CacheKey key, final EncodedImage encodedImage) {
    Preconditions.checkNotNull(key);
    Preconditions.checkNotNull(encodedImage);
    Preconditions.checkArgument(EncodedImage.isValid(encodedImage));

    final EncodedImage oldValue = mMap.get(key);

    if (oldValue == null) {
      return false;
    }

    CloseableReference<PooledByteBuffer> oldRef = oldValue.getByteBufferRef();
    CloseableReference<PooledByteBuffer> ref = encodedImage.getByteBufferRef();
    try {
      if (oldRef == null || ref == null || oldRef.get() != ref.get()) {
        return false;
      }
      mMap.remove(key);
    } finally {
      CloseableReference.closeSafely(ref);
      CloseableReference.closeSafely(oldRef);
      EncodedImage.closeSafely(oldValue);
    }

    logStats();
    return true;
  }
842232
def clear(self, correlation_id):
        
        self._lock.acquire()
        try:
            self._cache = {}
        finally:
            self._lock.release()
1277044
public static final void remove(String key) {
        Map<String, Object> ctx = CTX_HOLDER.get();
        if (ctx != null) {
            ctx.remove(key);
        }
    }
67408
public void clear(String cacheKey) {
        ValueCacheKey key = getRequestCacheKey(cacheKey);
        if (key != null) {
            ConcurrentHashMap<ValueCacheKey, HystrixCachedObservable<?>> cacheInstance = requestVariableForCache.get(concurrencyStrategy);
            if (cacheInstance == null) {
                throw new IllegalStateException("Request caching is not available. Maybe you need to initialize the HystrixRequestContext?");
            }

            /* remove this cache key */
            cacheInstance.remove(key);
        }
    }
394023
public int removeKey(final K key)
    {
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(key, mask);

        int value;
        while (missingValue != (value = values[index]))
        {
            if (key.equals(keys[index]))
            {
                keys[index] = null;
                values[index] = missingValue;
                --size;

                compactChain(index);
                break;
            }

            index = ++index & mask;
        }

        return value;
    }
855060
public void delete(String key) throws EtcdClientException {
        Preconditions.checkNotNull(key);

        URI uri = buildUriWithKeyAndParams(key, null);
        HttpDelete delete = new HttpDelete(uri);

        syncExecute(delete, new int[]{200, 404});
    }
569511
public V remove (int key)
    {
        Record<V> removed = removeImpl(key, true);
        return (removed == null) ? null : removed.value;
    }
1290309
@Override
	public void remove(final Object key, final Class<?> clas) {
		this.logger.debug("@remove :".concat(key.toString()).concat(" with class : ".concat(clas.getName())));
		getCachableMap(clas).remove(key);
	}
781278
public synchronized void remove(E key)
    {    
        Entry<E, T> entry = map.get(key);
        this.tail.prev = entry.prev;
        entry.prev.next = this.tail;
        map.remove(entry.key);
        this.length--;   
    }
258336
private void remove(K key, boolean withMissCount) {
		writeLock.lock();
		CacheObj<K, V> co;
		try {
			co = cacheMap.remove(key);
			if (withMissCount) {
				this.missCount--;
			}
		} finally {
			writeLock.unlock();
		}
		if (null != co) {
			onRemove(co.key, co.obj);
		}
	}