Java TimeValue.nanos方法代码示例

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void execute(Runnable command, final ScheduledExecutorService timer, final TimeValue timeout, final Runnable timeoutCallback) {
    if (command instanceof PrioritizedRunnable) {
        command = new TieBreakingPrioritizedRunnable((PrioritizedRunnable) command, insertionOrder.incrementAndGet());
    } else if (!(command instanceof PrioritizedFutureTask)) { // it might be a callable wrapper...
        command = new TieBreakingPrioritizedRunnable(command, Priority.NORMAL, insertionOrder.incrementAndGet());
    }
    super.execute(command);
    if (timeout.nanos() >= 0) {
        if (command instanceof TieBreakingPrioritizedRunnable) {
            ((TieBreakingPrioritizedRunnable) command).scheduleTimeout(timer, timeoutCallback, timeout);
        } else {
            // We really shouldn't be here. The only way we can get here if somebody created PrioritizedFutureTask
            // and passed it to execute, which doesn't make much sense
            throw new UnsupportedOperationException("Execute with timeout is not supported for future tasks");
        }
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void execute(Runnable command, final ScheduledExecutorService timer, final TimeValue timeout, final Runnable timeoutCallback) {
    command = wrapRunnable(command);
    doExecute(command);
    if (timeout.nanos() >= 0) {
        if (command instanceof TieBreakingPrioritizedRunnable) {
            ((TieBreakingPrioritizedRunnable) command).scheduleTimeout(timer, timeoutCallback, timeout);
        } else {
            // We really shouldn't be here. The only way we can get here if somebody created PrioritizedFutureTask
            // and passed it to execute, which doesn't make much sense
            throw new UnsupportedOperationException("Execute with timeout is not supported for future tasks");
        }
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private static TimeValue getValidThreshold(Settings settings, String key, String level) {
    TimeValue threshold = settings.getAsTime(level, null);
    if (threshold == null) {
        throw new IllegalArgumentException("missing gc_threshold for [" + getThresholdName(key, level) + "]");
    }
    if (threshold.nanos() <= 0) {
        throw new IllegalArgumentException("invalid gc_threshold [" + threshold + "] for [" + getThresholdName(key, level) + "]");
    }
    return threshold;
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
protected void processTasks(ListTasksRequest request, final Consumer<Task> operation) {
    if (false == request.getWaitForCompletion()) {
        super.processTasks(request, operation);
        return;
    }
    // If we should wait for completion then we have to intercept every found task and wait for it to leave the manager.
    TimeValue timeout = request.getTimeout();
    if (timeout == null) {
        timeout = DEFAULT_WAIT_FOR_COMPLETION_TIMEOUT;
    }
    final long timeoutTime = System.nanoTime() + timeout.nanos();
    super.processTasks(request, new Consumer<Task>() {
        @Override
        public void accept(Task t) {
            operation.accept(t);
            while (System.nanoTime() - timeoutTime < 0) {
                Task task = taskManager.getTask(t.getId());
                if (task == null) {
                    return;
                }
                if (task.getAction().startsWith(ListTasksAction.NAME)) {
                    // It doesn't make sense to wait for List Tasks and it can cause an infinite loop of the task waiting
                    // for itself of one of its child tasks
                    return;
                }
                try {
                    Thread.sleep(WAIT_FOR_COMPLETION_POLL.millis());
                } catch (InterruptedException e) {
                    throw new ElasticsearchException("Interrupted waiting for completion of [{}]", e, t);
                }
            }
            throw new ElasticsearchTimeoutException("Timed out waiting for completion of [{}]", t);
        }
    });
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setQueryWarnThreshold(TimeValue warnThreshold) {
    this.queryWarnThreshold = warnThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setQueryInfoThreshold(TimeValue infoThreshold) {
    this.queryInfoThreshold = infoThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setQueryDebugThreshold(TimeValue debugThreshold) {
    this.queryDebugThreshold = debugThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setQueryTraceThreshold(TimeValue traceThreshold) {
    this.queryTraceThreshold = traceThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setFetchWarnThreshold(TimeValue warnThreshold) {
    this.fetchWarnThreshold = warnThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setFetchInfoThreshold(TimeValue infoThreshold) {
    this.fetchInfoThreshold = infoThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setFetchDebugThreshold(TimeValue debugThreshold) {
    this.fetchDebugThreshold = debugThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setFetchTraceThreshold(TimeValue traceThreshold) {
    this.fetchTraceThreshold = traceThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setWarnThreshold(TimeValue warnThreshold) {
    this.indexWarnThreshold = warnThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setInfoThreshold(TimeValue infoThreshold) {
    this.indexInfoThreshold = infoThreshold.nanos();
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
private void setDebugThreshold(TimeValue debugThreshold) {
    this.indexDebugThreshold = debugThreshold.nanos();
}