Use this API to clear lbpersistentsessions resources.
548623
public static base_responses clear(nitro_service client, lbpersistentsessions resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			lbpersistentsessions clearresources[] = new lbpersistentsessions[resources.length];
			for (int i=0;i<resources.length;i++){
				clearresources[i] = new lbpersistentsessions();
				clearresources[i].vserver = resources[i].vserver;
				clearresources[i].persistenceparameter = resources[i].persistenceparameter;
			}
			result = perform_operation_bulk_request(client, clearresources,"clear");
		}
		return result;
	}
183807
def clear(self, *resource_types):
        """"""
        resource_types = resource_types or tuple(self.__caches.keys())

        for cls in resource_types:
            # Clear and delete cache instances to guarantee no lingering references
            self.__caches[cls].clear()
            del self.__caches[cls]
693612
def clear(self):
        
        with self._hlock:
            self.handlers.clear()
        with self._mlock:
            self.memoize.clear()
518415
private synchronized void clearEntries() {

        if (!isEnabled()) {
            return;
        }
        if (LOG.isInfoEnabled()) {
            LOG.info(Messages.get().getBundle().key(Messages.LOG_FLEXCACHE_CLEAR_ALL_0));
        }
        // create new set to avoid ConcurrentModificationExceptions
        Set<String> cacheKeys = synchronizedCopyKeys(m_keyCache);
        Iterator<String> i = cacheKeys.iterator();
        while (i.hasNext()) {
            CmsFlexCacheVariation v = m_keyCache.get(i.next());
            Iterator<I_CmsLruCacheObject> allEntries = v.m_map.values().iterator();
            while (allEntries.hasNext()) {
                I_CmsLruCacheObject nextObject = allEntries.next();
                allEntries.remove();
                m_variationCache.remove(nextObject);
            }
            v.m_map = new Hashtable<String, I_CmsLruCacheObject>(INITIAL_CAPACITY_VARIATIONS);
        }
        m_size = 0;
    }
384140
protected final void cacheClear() {

        int i = sysTables.length;

        while (i-- > 0) {
            Table t = sysTables[i];

            if (t != null) {
                t.clearAllData(session);
            }

            sysTableSessions[i] = null;
        }

        isDirty = false;
    }
1267814
public function clearState()
    {
        parent::clearState();
        $this->addedObjects = new \SplObjectStorage();
        $this->removedObjects = new \SplObjectStorage();
        $this->changedObjects = new \SplObjectStorage();
        $this->persistenceSession->destroy();
        $this->hasUnpersistedChanges = false;
    }
320118
@ManagedOperation
    public void clear() {
        Set<K> keys=new HashSet<>(l2_cache.getInternalMap().keySet());
        mcastClear(keys, false);
    }
977247
private void cleanupSession(){
        eventThread.queueClientEvent(new ClientSessionEvent(SessionEvent.CLOSED));
        watcherManager.cleanup();
        session.id = "";
        session.password = null;
        session.serverId = -1;
        onSessionClose();
    }
995055
protected void clearPartitions() {
		for (int i = this.partitionsBeingBuilt.size() - 1; i >= 0; --i) {
			final HashPartition<BT, PT> p = this.partitionsBeingBuilt.get(i);
			try {
				p.clearAllMemory(this.availableMemory);
			} catch (Exception e) {
				LOG.error("Error during partition cleanup.", e);
			}
		}
		this.partitionsBeingBuilt.clear();
	}
590813
private void clear() {
        boolPropertySet = null;
        databaseInputDir = null;
        databaseOutputDir = null;
        IO.close(project);
    }
499401
public synchronized void clearMemory() {
    Collection<TraceObject> traceObjects = values();
    for (TraceObject traceObject : traceObjects) {
      traceObject.remove();
    }
    this.clear();
  }
418109
public void clear() {
        this.attributes.clear();
        this.queryParameters = null;
        this.inReader = null;
        this.streamActive = false;
        this.inStream = null;
        this.encoding = null;
        this.sessionData = null;
        this.strippedURI = null;
        this.srvContext = null;
        this.srvPath = null;
        this.pathInfo = null;
        this.pathInfoComputed = false;
        this.filters = null;
    }
614758
final void clear() {
        reset();
        
        _freeQueue.clear();
        _targetQueue.clear();
        _compactedQueue.clear();
        while(!_updateManager.isServiceQueueEmpty()) {
            CompactionUpdateBatch batch = _updateManager.pollBatch();
            _updateManager.recycleBatch(batch);
        }
    }
157821
@Override
    public final void clearProperties() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "clearProperties");

        if (mayHaveJmsUserProperties()) {
            getJmsUserPropertyMap().clear();
        }
        if (mayHaveMappedJmsSystemProperties()) {
            getJmsSystemPropertyMap().clear();
        }
        clearSmokeAndMirrorsProperties();
        if (hasMQMDPropertiesSet()) {
            getMQMDSetPropertiesMap().clear();
        }

        // Clear the super-classes cached lengths, but NOT anything pertaining to the payload
        super.clearCachedLengths();
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "clearProperties");
    }
283177
public void disconnectAllSessions() {

        List<JingleSession> sessions = jingleSessions.subList(0, jingleSessions.size());

        for (JingleSession jingleSession : sessions)
            try {
                jingleSession.terminate();
            } catch (Exception e) {
                LOGGER.log(Level.WARNING, "exception", e);
            }

        sessions.clear();
    }
152487
@Override
	public void clear() {
		lock.writeLock().lock();
		try {
			properties.clear();
		} finally {
			lock.writeLock().unlock();
		}
	}
56322
public void clear() {
        synchronized (mLock) {
            if (mOriginalValues != null) {
                mOriginalValues.clear();
            } else {
                mObjects.clear();
            }
        }
        if (mNotifyOnChange) notifyDataSetChanged();
    }