Removes a channel from the cache.

@param channelId The id of the channel to remove.
777038
public void removeChannelFromCache(long channelId) {
        channels.computeIfPresent(channelId, (key, channel) -> {
            if (channel instanceof Cleanupable) {
                ((Cleanupable) channel).cleanup();
            }
            return null;
        });
    }
8513
public void remove (int objectID) {
		Object object = idToObject.remove(objectID);
		if (object != null) objectToID.remove(object, 0);
		if (TRACE) trace("kryonet", "Object " + objectID + " removed from ObjectSpace: " + object);
	}
668018
public AlertPolicyChannelService delete(long policyId, long channelId)
    {
        QueryParameterList queryParams = new QueryParameterList();
        queryParams.add("policy_id", policyId);
        queryParams.add("channel_id", channelId);
        HTTP.DELETE("/v2/alerts_policy_channels.json", null, queryParams);       
        return this;
    }
1367912
public function removeItem($cacheId)
    {
        $cacheId = $this->normalizeKey($cacheId);

        unset($this->map[$cacheId]);

        return true;
    }
1042702
public function hold($channelId)
    {
        $uri = "channels/$channelId/hold";
        try {
            $this->client->getEndpoint()->post($uri);
        } catch (RequestException $e) {
            $this->processRequestException($e);
        }
    }
84311
void removeEntry(NodeId nodeId) throws Exception {
		this.entryCache.remove(nodeId);
		this.entries.remove(nodeId);
	}
719817
def remove_channel(self, channel, *, verbose=True):
        
        channel_index = wt_kit.get_index(self.channel_names, channel)
        new = list(self.channel_names)
        name = new.pop(channel_index)
        del self[name]
        self.channel_names = new
        if verbose:
            print("channel {0} removed".format(name))
415929
public function removeChannel($id)
    {
        $channel = $this->em
            ->getRepository('CampaignChainCoreBundle:Channel')
            ->find($id);

        if (!$channel) {
            throw new \Exception(
                'No channel found for id '.$id
            );
        }
        //
        $locations = $channel->getLocations();

        $openActivities = new ArrayCollection();
        $closedActivities = new ArrayCollection();
        foreach ($locations as $location) {
            foreach ($location->getActivities() as $activity) {
                if ($activity->getStatus() == 'closed') {
                    $closedActivities->add($activity);
                } else {
                    $openActivities->add($activity);
                }
            }
        }

        if (!$closedActivities->isEmpty()) {
            //deaktivieren
        } else {
            foreach ($openActivities as $activity) {
                $this->activityService->removeActivity($activity);
            }
            foreach ($locations as $location) {
                $this->locationService->removeLocation($location);
            }
            $this->em->remove($channel);
            $this->em->flush();
        }
    }
884102
public void destroy() {
        setState(STATE_STOPPED);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "destroy: " + this);
        }
        this.channelFactory.removeChannel(getName());
        this.channelFactory = null;
        this.myConfig = null;
        this.myObjectFactory = null;
    }
719255
public void clear(String layerName) {
        synchronized (this) {
            log.info("clearing cache for layer " + layerName);
            for (String key : cache.keySet()) {
                if (key.contains(layerName))
                    remove(key);
            }
        }
    }
1067727
public void remove(Channel channel)
    {
        synchronized (this._associatedChannels)
        {
            int index = findChannel(channel);
            if (index != -1)
            {
                if (logger.isDebugEnabled())
                    logger.debug(
                            "CallTracker removing channel: " + this.toString() + " " + channel.getExtendedChannelName()); //$NON-NLS-1$ //$NON-NLS-2$

                this._associatedChannels.remove(index);
            }
        }

    }
249429
def delete_channel(self, chname):
        """"""
        name = chname.lower()

        if len(self.channel_names) < 1:
            self.logger.error('Delete channel={0} failed. '
                              'No channels left.'.format(chname))
            return

        with self.lock:
            channel = self.channel[name]

            # Close local plugins open on this channel
            self.close_plugins(channel)

            try:
                idx = self.channel_names.index(chname)
            except ValueError:
                idx = 0

            # Update the channels control
            self.channel_names.remove(channel.name)
            self.channel_names.sort()

            self.ds.remove_tab(chname)
            del self.channel[name]
            self.prefs.remove_settings('channel_' + chname)

            # pick new channel
            num_channels = len(self.channel_names)
            if num_channels > 0:
                if idx >= num_channels:
                    idx = num_channels - 1
                self.change_channel(self.channel_names[idx])
            else:
                self.cur_channel = None

        self.make_gui_callback('delete-channel', channel)
428857
public void destory(Long channelId) {
        String path = ManagePathUtils.getChannelByChannelId(channelId);
        try {
            zookeeper.delete(path); // 删除节点，不关心版本
        } catch (ZkNoNodeException e) {
            // 如果节点已经不存在，则不抛异常
            // ignore
        } catch (ZkException e) {
            throw new ArbitrateException("Channel_destory", channelId.toString(), e);
        }
    }
181121
function (identifier)  {
    var path;
    if (identifier) {
      path = this.constructPath(constants.CHANNELS, identifier);
      return this.Core.DELETE(path);
    } else {
      return this.rejectRequest('Bad Request: A channel identifier is required.');
    }
  }
1217624
private void remove(final ProviderIdent ident) {
        final cacheItem cacheItem = cache.get(ident);
        if (null != cacheItem) {
            filecache.remove(cacheItem.getFirst());
        }
        cache.remove(ident);
    }
614086
public final synchronized void removeId(long id)
	{
		if (tc.isEntryEnabled()) Tr.entry(tc, "removeId", new Long(id));

		_idMap.remove(id);

		if (tc.isEntryEnabled()) Tr.exit(tc, "removeId");
	}
1364690
public synchronized void removeHandler(String handlerId) {
		handlerEventMap.remove(handlerId);
		Tr.event(tc, "Removed Asynchronous Handler: " + handlerId);
		if (handlerEventMap.isEmpty()) {
			ringBuffer = null;
			Tr.event(tc, "ringBuffer for this BufferManagerImpl has now been set to null");
		}
	}