Release the lock for a given key.

@param string $key

@return bool
769007
protected function unlock($key)
    {
        $path = $key.'.lock';
        try {
            $this->filesystem->delete($path);
        } catch (FileNotFoundException $e) {
            return false;
        }

        return true;
    }
999684
private function forceClear($key)
    {
        try {
            return $this->filesystem->delete($this->getFilePath($key));
        } catch (FileNotFoundException $e) {
            return true;
        }
    }
848053
protected function lock($key)
    {
        $path = $key.'.lock';

        for ($i = 0; $i < 25; ++$i) {
            try {
                $this->filesystem->write($path, '');

                return true;
            } catch (FileExistsException $e) {
                usleep(200);
            }
        }

        return false;
    }
1116634
public function forceDelete($key)
    {
        !is_null($this->cache) && $this->cache->forget($this->cacheKey);
        $model = $this->resolver()->where('name', $key);
        if (!is_null($model)) {
            return $model->delete();
        }
        return false;
    }
1092040
public function remove($key): bool
    {
        $removed = false;
        $bucket = $this->locate($key);

        if ($bucket !== null) {
            $this->removeBucket($bucket);
            $this->rewind();
            $removed = true;
        }

        return $removed;
    }
23599
public function releaseLock($name)
    {
        if (isset($this->locks[$name])) {
            rmdir($this->getDirectoryPath($name));
            unset($this->locks[$name]);

            return true;
        }

        return false;
    }
847777
public function delete($key)
    {
        if ($this->enabled) {
            return $this->pool->getItem($key)->clear();
        } else {
            return false;
        }
    }
22821
public function remove($key)
    {
        if (array_key_exists($key, $this->settings)) {
            unset($this->settings[$key]);
            return true;
        }
        return false;
    }
663871
public function removeKey($key)
    {
        if ($this->hasKey($key)) {
            unset($this->container[$key]);
            return true;
        } else {
            return false;
        }
    }
1348994
public function remove($key)
    {
        foreach ($this->options as $idx => $option) {
            if (is_array($option)) {
                if (! strcasecmp($key, $option['name'])) {
                    unset($this->options[$idx]);

                    return true;
                }
            } elseif (! strcasecmp($key, $option)) {
                unset($this->options[$idx]);

                return true;
            }
        }

        return false;
    }
1299294
public function delete($key): bool
    {
        $this->checkKey($key);
        return (bool) $this->clean($key);
    }
1312252
public static function remove($key)
		{
			self::_cleanPrevious();

			if(self::is($key))
			{
				unset($_SESSION[self::$_sessionKey.$key]);
				return true;
			}
			else
			{
				return false;
			}
		}
71402
public function release_lock(lock $lock) {
        $handle = $lock->get_key();

        if (!$handle) {
            // We didn't have a lock.
            return false;
        }

        $result = flock($handle, LOCK_UN);
        fclose($handle);
        return $result;
    }
230205
public function forget($key)
    {
        if ($this->files->exists($file = $this->path($key))) {
            return $this->files->delete($file);
        }

        return false;
    }
840102
public function release($key)
    {
        if (isset($this->resources[$key])) {
            $fd = $this->resources[$key];
            unset($this->resources[$key]);
            @flock($fd, LOCK_UN);
            @fclose($fd);
            try {
                @unlink($this->getFilenameForMutexKey($key));
            } catch (Exception $x) {
            }
        }
    }
673233
public function delete(string $key): bool
    {
        $this->checkConnection(__METHOD__);
        $delete = $this->engine->delete($key);
        if ($delete && $this->index) {
            $this->index->events()
                ->trigger(Indexing::EVENT_ON_DELETE)
                ->params($key)
                ->fire();
        }

        return $delete;
    }
741873
public function remove($key)
    {
        if (!$this->isEnabled() || !$this->has($key)) {
            return false;
        }

        eaccelerator_rm($this->prefix() . $key);

        return true;
    }