Java TimeValue.nsecToMSec方法代码示例

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Stop the current task. The results are undefined if timing
 * methods are called without invoking at least one pair
 * {@link #start()} / {@link #stop()} methods.
 *
 * @see #start()
 */
public StopWatch stop() throws IllegalStateException {
    if (!this.running) {
        throw new IllegalStateException("Can't stop StopWatch: it's not running");
    }
    long lastTimeNS = System.nanoTime() - this.startTimeNS;
    this.totalTimeNS += lastTimeNS;
    this.lastTaskInfo = new TaskInfo(this.currentTaskName, TimeValue.nsecToMSec(lastTimeNS));
    if (this.keepTaskList) {
        this.taskList.add(lastTaskInfo);
    }
    ++this.taskCount;
    this.running = false;
    this.currentTaskName = null;
    return this;
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
long getThrottleTimeInMillis() {
    long currentThrottleNS = 0;
    if (isThrottled() && startOfThrottleNS != 0) {
        currentThrottleNS +=  System.nanoTime() - startOfThrottleNS;
        if (currentThrottleNS < 0) {
            // Paranoia (System.nanoTime() is supposed to be monotonic): time slip must have happened, have to ignore this value
            currentThrottleNS = 0;
        }
    }
    return throttleTimeMillisMetric.count() + TimeValue.nsecToMSec(currentThrottleNS);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
public void onTimeout(TimeValue timeout) {
    ObservingContext context = observingContext.getAndSet(null);
    if (context != null) {
        clusterService.removeTimeoutListener(this);
        long timeSinceStartMS = TimeValue.nsecToMSec(System.nanoTime() - startTimeNS);
        logger.trace("observer: timeout notification from cluster service. timeout setting [{}], time since start [{}]", timeOutValue, new TimeValue(timeSinceStartMS));
        // update to latest, in case people want to retry
        lastObservedState.set(new StoredState(clusterService.state()));
        timedOut = true;
        context.listener.onTimeout(timeOutValue);
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Resets and returns elapsed time in milliseconds.
 */
public long reset() {
    long nowNS = System.nanoTime();
    try {
        return TimeValue.nsecToMSec(nowNS - startNS);
    } finally {
        startNS = nowNS;
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
CachedTimeThread(String name, long interval) {
    super(name);
    this.interval = interval;
    this.relativeMillis = TimeValue.nsecToMSec(System.nanoTime());
    this.absoluteMillis = System.currentTimeMillis();
    this.counter = new TimeCounter();
    setDaemon(true);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
public void run() {
    while (running) {
        relativeMillis = TimeValue.nsecToMSec(System.nanoTime());
        absoluteMillis = System.currentTimeMillis();
        try {
            Thread.sleep(interval);
        } catch (InterruptedException e) {
            running = false;
            return;
        }
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
public void onTimeout(TimeValue timeout) {
    ObservingContext context = observingContext.getAndSet(null);
    if (context != null) {
        clusterService.remove(this);
        long timeSinceStartMS = TimeValue.nsecToMSec(System.nanoTime() - startTimeNS);
        logger.trace("observer: timeout notification from cluster service. timeout setting [{}], time since start [{}]", timeOutValue, new TimeValue(timeSinceStartMS));
        // update to latest, in case people want to retry
        lastObservedState.set(new ObservedState(clusterService.state()));
        timedOut = true;
        context.listener.onTimeout(timeOutValue);
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
EstimatedTimeThread(String name, long interval) {
    super(name);
    this.interval = interval;
    this.estimatedTimeInMillis = TimeValue.nsecToMSec(System.nanoTime());
    this.counter = new TimeCounter();
    setDaemon(true);
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
public void run() {
    while (running) {
        estimatedTimeInMillis = TimeValue.nsecToMSec(System.nanoTime());
        try {
            Thread.sleep(interval);
        } catch (InterruptedException e) {
            running = false;
            return;
        }
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
public void testTimeoutPerConnection() throws IOException {
    assumeTrue("Works only on BSD network stacks and apparently windows",
        Constants.MAC_OS_X || Constants.FREE_BSD || Constants.WINDOWS);
    try (ServerSocket socket = new MockServerSocket()) {
        // note - this test uses backlog=1 which is implementation specific ie. it might not work on some TCP/IP stacks
        // on linux (at least newer ones) the listen(addr, backlog=1) should just ignore new connections if the queue is full which
        // means that once we received an ACK from the client we just drop the packet on the floor (which is what we want) and we run
        // into a connection timeout quickly. Yet other implementations can for instance can terminate the connection within the 3 way
        // handshake which I haven't tested yet.
        socket.bind(new InetSocketAddress(InetAddress.getLocalHost(), 0), 1);
        socket.setReuseAddress(true);
        DiscoveryNode first = new DiscoveryNode("TEST", new TransportAddress(socket.getInetAddress(),
            socket.getLocalPort()), emptyMap(),
            emptySet(), version0);
        DiscoveryNode second = new DiscoveryNode("TEST", new TransportAddress(socket.getInetAddress(),
            socket.getLocalPort()), emptyMap(),
            emptySet(), version0);
        ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
        builder.addConnections(1,
            TransportRequestOptions.Type.BULK,
            TransportRequestOptions.Type.PING,
            TransportRequestOptions.Type.RECOVERY,
            TransportRequestOptions.Type.REG,
            TransportRequestOptions.Type.STATE);
        // connection with one connection and a large timeout -- should consume the one spot in the backlog queue
        try (TransportService service = buildService("TS_TPC", Version.CURRENT, null,
            Settings.EMPTY, true, false)) {
            IOUtils.close(service.openConnection(first, builder.build()));
            builder.setConnectTimeout(TimeValue.timeValueMillis(1));
            final ConnectionProfile profile = builder.build();
            // now with the 1ms timeout we got and test that is it's applied
            long startTime = System.nanoTime();
            ConnectTransportException ex = expectThrows(ConnectTransportException.class, () -> service.openConnection(second, profile));
            final long now = System.nanoTime();
            final long timeTaken = TimeValue.nsecToMSec(now - startTime);
            assertTrue("test didn't timeout quick enough, time taken: [" + timeTaken + "]",
                timeTaken < TimeValue.timeValueSeconds(5).millis());
            assertEquals(ex.getMessage(), "[][" + second.getAddress() + "] connect_timeout[1ms]");
        }
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
protected void doMerge(IndexWriter writer, MergePolicy.OneMerge merge) throws IOException {
    int totalNumDocs = merge.totalNumDocs();
    long totalSizeInBytes = merge.totalBytesSize();
    long timeNS = System.nanoTime();
    currentMerges.inc();
    currentMergesNumDocs.inc(totalNumDocs);
    currentMergesSizeInBytes.inc(totalSizeInBytes);

    OnGoingMerge onGoingMerge = new OnGoingMerge(merge);
    onGoingMerges.add(onGoingMerge);

    if (logger.isTraceEnabled()) {
        logger.trace("merge [{}] starting..., merging [{}] segments, [{}] docs, [{}] size, into [{}] estimated_size", OneMergeHelper.getSegmentName(merge), merge.segments.size(), totalNumDocs, new ByteSizeValue(totalSizeInBytes), new ByteSizeValue(merge.estimatedMergeBytes));
    }
    try {
        beforeMerge(onGoingMerge);
        super.doMerge(writer, merge);
    } finally {
        long tookMS = TimeValue.nsecToMSec(System.nanoTime() - timeNS);

        onGoingMerges.remove(onGoingMerge);
        afterMerge(onGoingMerge);

        currentMerges.dec();
        currentMergesNumDocs.dec(totalNumDocs);
        currentMergesSizeInBytes.dec(totalSizeInBytes);

        totalMergesNumDocs.inc(totalNumDocs);
        totalMergesSizeInBytes.inc(totalSizeInBytes);
        totalMerges.inc(tookMS);

        long stoppedMS = TimeValue.nsecToMSec(merge.rateLimiter.getTotalStoppedNS());
        long throttledMS = TimeValue.nsecToMSec(merge.rateLimiter.getTotalPausedNS());

        totalMergeStoppedTime.inc(stoppedMS);
        totalMergeThrottledTime.inc(throttledMS);

        String message = String.format(Locale.ROOT,
                                       "merge segment [%s] done: took [%s], [%,.1f MB], [%,d docs], [%s stopped], [%s throttled], [%,.1f MB written], [%,.1f MB/sec throttle]",
                                       OneMergeHelper.getSegmentName(merge),
                                       TimeValue.timeValueMillis(tookMS),
                                       totalSizeInBytes/1024f/1024f,
                                       totalNumDocs,
                                       TimeValue.timeValueMillis(stoppedMS),
                                       TimeValue.timeValueMillis(throttledMS),
                                       merge.rateLimiter.getTotalBytesWritten()/1024f/1024f,
                                       merge.rateLimiter.getMBPerSec());

        if (tookMS > 20000) { // if more than 20 seconds, DEBUG log it
            logger.debug("{}", message);
        } else if (logger.isTraceEnabled()) {
            logger.trace("{}", message);
        }
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Wait for the next cluster state which satisfies statePredicate
 *
 * @param listener        callback listener
 * @param statePredicate predicate to check whether cluster state changes are relevant and the callback should be called
 * @param timeOutValue    a timeout for waiting. If null the global observer timeout will be used.
 */
public void waitForNextChange(Listener listener, Predicate<ClusterState> statePredicate, @Nullable TimeValue timeOutValue) {
    listener = new ContextPreservingListener(listener, contextHolder.newRestorableContext(false));
    if (observingContext.get() != null) {
        throw new ElasticsearchException("already waiting for a cluster state change");
    }

    Long timeoutTimeLeftMS;
    if (timeOutValue == null) {
        timeOutValue = this.timeOutValue;
        if (timeOutValue != null) {
            long timeSinceStartMS = TimeValue.nsecToMSec(System.nanoTime() - startTimeNS);
            timeoutTimeLeftMS = timeOutValue.millis() - timeSinceStartMS;
            if (timeoutTimeLeftMS <= 0L) {
                // things have timeout while we were busy -> notify
                logger.trace("observer timed out. notifying listener. timeout setting [{}], time since start [{}]", timeOutValue, new TimeValue(timeSinceStartMS));
                // update to latest, in case people want to retry
                timedOut = true;
                lastObservedState.set(new StoredState(clusterService.state()));
                listener.onTimeout(timeOutValue);
                return;
            }
        } else {
            timeoutTimeLeftMS = null;
        }
    } else {
        this.startTimeNS = System.nanoTime();
        this.timeOutValue = timeOutValue;
        timeoutTimeLeftMS = timeOutValue.millis();
        timedOut = false;
    }

    // sample a new state. This state maybe *older* than the supplied state if we are called from an applier,
    // which wants to wait for something else to happen
    ClusterState newState = clusterService.state();
    if (lastObservedState.get().isOlderOrDifferentMaster(newState) && statePredicate.test(newState)) {
        // good enough, let's go.
        logger.trace("observer: sampled state accepted by predicate ({})", newState);
        lastObservedState.set(new StoredState(newState));
        listener.onNewClusterState(newState);
    } else {
        logger.trace("observer: sampled state rejected by predicate ({}). adding listener to ClusterService", newState);
        final ObservingContext context = new ObservingContext(listener, statePredicate);
        if (!observingContext.compareAndSet(null, context)) {
            throw new ElasticsearchException("already waiting for a cluster state change");
        }
        clusterService.addTimeoutListener(timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS), clusterStateListener);
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
@Override
protected void doMerge(IndexWriter writer, MergePolicy.OneMerge merge) throws IOException {
    int totalNumDocs = merge.totalNumDocs();
    long totalSizeInBytes = merge.totalBytesSize();
    long timeNS = System.nanoTime();
    currentMerges.inc();
    currentMergesNumDocs.inc(totalNumDocs);
    currentMergesSizeInBytes.inc(totalSizeInBytes);

    OnGoingMerge onGoingMerge = new OnGoingMerge(merge);
    onGoingMerges.add(onGoingMerge);

    if (logger.isTraceEnabled()) {
        logger.trace("merge [{}] starting..., merging [{}] segments, [{}] docs, [{}] size, into [{}] estimated_size", OneMergeHelper.getSegmentName(merge), merge.segments.size(), totalNumDocs, new ByteSizeValue(totalSizeInBytes), new ByteSizeValue(merge.estimatedMergeBytes));
    }
    try {
        beforeMerge(onGoingMerge);
        super.doMerge(writer, merge);
    } finally {
        long tookMS = TimeValue.nsecToMSec(System.nanoTime() - timeNS);

        onGoingMerges.remove(onGoingMerge);
        afterMerge(onGoingMerge);

        currentMerges.dec();
        currentMergesNumDocs.dec(totalNumDocs);
        currentMergesSizeInBytes.dec(totalSizeInBytes);

        totalMergesNumDocs.inc(totalNumDocs);
        totalMergesSizeInBytes.inc(totalSizeInBytes);
        totalMerges.inc(tookMS);

        long stoppedMS = TimeValue.nsecToMSec(merge.rateLimiter.getTotalStoppedNS());
        long throttledMS = TimeValue.nsecToMSec(merge.rateLimiter.getTotalPausedNS());

        totalMergeStoppedTime.inc(stoppedMS);
        totalMergeThrottledTime.inc(throttledMS);

        String message = String.format(Locale.ROOT,
                                       "merge segment [%s] done: took [%s], [%,.1f MB], [%,d docs], [%s stopped], [%s throttled], [%,.1f MB written], [%,.1f MB/sec throttle]",
                                       OneMergeHelper.getSegmentName(merge),
                                       TimeValue.timeValueMillis(tookMS),
                                       totalSizeInBytes/1024f/1024f,
                                       totalNumDocs,
                                       TimeValue.timeValueMillis(stoppedMS),
                                       TimeValue.timeValueMillis(throttledMS),
                                       merge.rateLimiter.getTotalBytesWritten()/1024f/1024f,
                                       merge.rateLimiter.getMBPerSec());

        if (tookMS > 20000) { // if more than 20 seconds, DEBUG log it
            logger.debug(message);
        } else if (logger.isTraceEnabled()) {
            logger.trace(message);
        }
    }
}
 

import org.elasticsearch.common.unit.TimeValue; //导入方法依赖的package包/类
/**
 * Wait for the next cluster state which satisfies changePredicate
 *
 * @param listener        callback listener
 * @param changePredicate predicate to check whether cluster state changes are relevant and the callback should be called
 * @param timeOutValue    a timeout for waiting. If null the global observer timeout will be used.
 */
public void waitForNextChange(Listener listener, ChangePredicate changePredicate, @Nullable TimeValue timeOutValue) {

    if (observingContext.get() != null) {
        throw new ElasticsearchException("already waiting for a cluster state change");
    }

    Long timeoutTimeLeftMS;
    if (timeOutValue == null) {
        timeOutValue = this.timeOutValue;
        if (timeOutValue != null) {
            long timeSinceStartMS = TimeValue.nsecToMSec(System.nanoTime() - startTimeNS);
            timeoutTimeLeftMS = timeOutValue.millis() - timeSinceStartMS;
            if (timeoutTimeLeftMS <= 0l) {
                // things have timeout while we were busy -> notify
                logger.trace("observer timed out. notifying listener. timeout setting [{}], time since start [{}]", timeOutValue, new TimeValue(timeSinceStartMS));
                // update to latest, in case people want to retry
                timedOut = true;
                lastObservedState.set(new ObservedState(clusterService.state()));
                listener.onTimeout(timeOutValue);
                return;
            }
        } else {
            timeoutTimeLeftMS = null;
        }
    } else {
        this.startTimeNS = System.nanoTime();
        this.timeOutValue = timeOutValue;
        timeoutTimeLeftMS = timeOutValue.millis();
        timedOut = false;
    }

    // sample a new state
    ObservedState newState = new ObservedState(clusterService.state());
    ObservedState lastState = lastObservedState.get();
    if (changePredicate.apply(lastState.clusterState, lastState.status, newState.clusterState, newState.status)) {
        // good enough, let's go.
        logger.trace("observer: sampled state accepted by predicate ({})", newState);
        lastObservedState.set(newState);
        listener.onNewClusterState(newState.clusterState);
    } else {
        logger.trace("observer: sampled state rejected by predicate ({}). adding listener to ClusterService", newState);
        ObservingContext context = new ObservingContext(listener, changePredicate);
        if (!observingContext.compareAndSet(null, context)) {
            throw new ElasticsearchException("already waiting for a cluster state change");
        }
        clusterService.add(timeoutTimeLeftMS == null ? null : new TimeValue(timeoutTimeLeftMS), clusterStateListener);
    }
}