Java Releasables.close方法代码示例

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
public void close() {
    List<Releasable> closeables = new ArrayList<>();
    for (OrdinalMapAndAtomicFieldData fds : atomicFD.values()) {
        closeables.addAll(Arrays.asList(fds.fieldData));
    }
    Releasables.close(closeables);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
public void clearReleasables(Lifetime lifetime) {
    if (clearables != null) {
        List<Collection<Releasable>> releasables = new ArrayList<>();
        for (Lifetime lc : Lifetime.values()) {
            if (lc.compareTo(lifetime) > 0) {
                break;
            }
            releasables.add(clearables.removeAll(lc));
        }
        Releasables.close(Iterables.concat(releasables));
    }
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
public void clearReleasables(Lifetime lifetime) {
    if (clearables != null) {
        List<List<Releasable>>releasables = new ArrayList<>();
        for (Lifetime lc : Lifetime.values()) {
            if (lc.compareTo(lifetime) > 0) {
                break;
            }
            List<Releasable> remove = clearables.remove(lc);
            if (remove != null) {
                releasables.add(remove);
            }
        }
        Releasables.close(Iterables.flatten(releasables));
    }
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
protected ExplainResponse shardOperation(ExplainRequest request, ShardId shardId) throws IOException {
    ShardSearchLocalRequest shardSearchLocalRequest = new ShardSearchLocalRequest(shardId,
        new String[]{request.type()}, request.nowInMillis, request.filteringAlias());
    SearchContext context = searchService.createSearchContext(shardSearchLocalRequest, SearchService.NO_TIMEOUT, null);
    Term uidTerm = new Term(UidFieldMapper.NAME, Uid.createUidAsBytes(request.type(), request.id()));
    Engine.GetResult result = null;
    try {
        result = context.indexShard().get(new Engine.Get(false, uidTerm));
        if (!result.exists()) {
            return new ExplainResponse(shardId.getIndexName(), request.type(), request.id(), false);
        }
        context.parsedQuery(context.getQueryShardContext().toQuery(request.query()));
        context.preProcess(true);
        int topLevelDocId = result.docIdAndVersion().docId + result.docIdAndVersion().context.docBase;
        Explanation explanation = context.searcher().explain(context.query(), topLevelDocId);
        for (RescoreSearchContext ctx : context.rescore()) {
            Rescorer rescorer = ctx.rescorer();
            explanation = rescorer.explain(topLevelDocId, context, ctx, explanation);
        }
        if (request.storedFields() != null || (request.fetchSourceContext() != null && request.fetchSourceContext().fetchSource())) {
            // Advantage is that we're not opening a second searcher to retrieve the _source. Also
            // because we are working in the same searcher in engineGetResult we can be sure that a
            // doc isn't deleted between the initial get and this call.
            GetResult getResult = context.indexShard().getService().get(result, request.id(), request.type(), request.storedFields(), request.fetchSourceContext());
            return new ExplainResponse(shardId.getIndexName(), request.type(), request.id(), true, explanation, getResult);
        } else {
            return new ExplainResponse(shardId.getIndexName(), request.type(), request.id(), true, explanation);
        }
    } catch (IOException e) {
        throw new ElasticsearchException("Could not explain", e);
    } finally {
        Releasables.close(result, context);
    }
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
public void doClose() {
    Releasables.close(tops, bottoms, posLefts, posRights, negLefts, negRights);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
protected void doClose() {
    Releasables.close(bucketOrds);
    super.doClose();
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
protected void doClose() {
    Releasables.close(topDocsCollectors);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
public void close() {
    Releasables.close(parentIdxs, scores);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
protected void doClose() {
    Releasables.close(states);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
public void applyFailedShards(FailedRerouteAllocation allocation) {
    for (FailedRerouteAllocation.FailedShard shard : allocation.failedShards()) {
        Releasables.close(asyncFetchStarted.remove(shard.shard.shardId()));
        Releasables.close(asyncFetchStore.remove(shard.shard.shardId()));
    }
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
public void close() {
    Releasables.close(runLens, hashSet.sizes);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
public void close() {
    Releasables.close(parentIdxs, scores, occurrences);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
public void close() {
    Releasables.close(visitedOrds);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
public void doClose() {
    Releasables.close(counts, sums);
}
 

import org.elasticsearch.common.lease.Releasables; //导入方法依赖的package包/类
@Override
public Weight doCreateWeight(IndexSearcher searcher, boolean needsScores) throws IOException {
    SearchContext sc = SearchContext.current();

    IndexParentChildFieldData globalIfd = ifd.loadGlobal((DirectoryReader)searcher.getIndexReader());
    if (globalIfd == null) {
        // No docs of the specified type exist on this shard
        return new BooleanQuery.Builder().build().createWeight(searcher, needsScores);
    }

    boolean abort = true;
    long numFoundParents;
    ParentCollector collector = null;
    try {
        if (minChildren == 0 && maxChildren == 0 && scoreType != ScoreType.NONE) {
            switch (scoreType) {
            case MIN:
                collector = new MinCollector(globalIfd, sc, parentType);
                break;
            case MAX:
                collector = new MaxCollector(globalIfd, sc, parentType);
                break;
            case SUM:
                collector = new SumCollector(globalIfd, sc, parentType);
                break;
            }
        }
        if (collector == null) {
            switch (scoreType) {
            case MIN:
                collector = new MinCountCollector(globalIfd, sc, parentType);
                break;
            case MAX:
                collector = new MaxCountCollector(globalIfd, sc, parentType);
                break;
            case SUM:
            case AVG:
                collector = new SumCountAndAvgCollector(globalIfd, sc, parentType);
                break;
            case NONE:
                collector = new CountCollector(globalIfd, sc, parentType);
                break;
            default:
                throw new RuntimeException("Are we missing a score type here? -- " + scoreType);
            }
        }

        searcher.search(childQuery, collector);
        numFoundParents = collector.foundParents();
        if (numFoundParents == 0) {
            return new BooleanQuery.Builder().build().createWeight(searcher, needsScores);
        }
        abort = false;
    } finally {
        if (abort) {
            Releasables.close(collector);
        }
    }
    sc.addReleasable(collector, Lifetime.COLLECTION);
    final Filter parentFilter;
    if (numFoundParents <= shortCircuitParentDocSet) {
        parentFilter = ParentIdsFilter.createShortCircuitFilter(nonNestedDocsFilter, sc, parentType, collector.values,
                collector.parentIdxs, numFoundParents);
    } else {
        parentFilter = this.parentFilter;
    }
    return new ParentWeight(this, childQuery.createWeight(searcher, needsScores), parentFilter, numFoundParents, collector, minChildren,
            maxChildren);
}