Java TimeUnit.toMillis方法代码示例

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
/**
 * Closes connections that have been idle longer than the given period
 * of time and evicts them from the pool.
 *
 * @param idletime maximum idle time.
 * @param tunit time unit.
 */
public void closeIdle(final long idletime, final TimeUnit tunit) {
    Args.notNull(tunit, "Time unit");
    long time = tunit.toMillis(idletime);
    if (time < 0) {
        time = 0;
    }
    final long deadline = System.currentTimeMillis() - time;
    enumAvailable(new PoolEntryCallback<T, C>() {

        @Override
        public void process(final PoolEntry<T, C> entry) {
            if (entry.getUpdated() <= deadline) {
                entry.close();
            }
        }

    });
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
public synchronized T get(final long timeout, final TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
    Args.notNull(unit, "Time unit");
    final long msecs = unit.toMillis(timeout);
    final long startTime = (msecs <= 0) ? 0 : System.currentTimeMillis();
    long waitTime = msecs;
    if (this.completed) {
        return getResult();
    } else if (waitTime <= 0) {
        throw new TimeoutException();
    } else {
        for (;;) {
            wait(waitTime);
            if (this.completed) {
                return getResult();
            } else {
                waitTime = msecs - (System.currentTimeMillis() - startTime);
                if (waitTime <= 0) {
                    throw new TimeoutException();
                }
            }
        }
    }
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {

    long deadline = System.currentTimeMillis() + unit.toMillis(timeout);

    synchronized (workers) {
        while (!isTerminated()) {
            long waitTime = deadline - System.currentTimeMillis();
            if (waitTime <= 0) {
                break;
            }

            workers.wait(waitTime);
        }
    }
    return isTerminated();
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
public Request(Object id, Object message, boolean useResponseQueue, long timeout, TimeUnit unit) {
    if (id == null) {
        throw new IllegalArgumentException("id");
    }
    if (message == null) {
        throw new IllegalArgumentException("message");
    }
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout: " + timeout + " (expected: 0+)");
    } else if (timeout == 0) {
        timeout = Long.MAX_VALUE;
    }

    if (unit == null) {
        throw new IllegalArgumentException("unit");
    }

    this.id = id;
    this.message = message;
    this.responses = useResponseQueue ? new LinkedBlockingQueue<Object>() : null;
    this.timeoutMillis = unit.toMillis(timeout);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
@Override
public RScheduledFuture<?> scheduleWithFixedDelayAsync(Runnable task, long initialDelay, long delay, TimeUnit unit) {
    check(task);
    byte[] classBody = getClassBody(task);
    byte[] state = encode(task);
    long startTime = System.currentTimeMillis() + unit.toMillis(initialDelay);
    RemotePromise<Void> result = (RemotePromise<Void>) asyncScheduledServiceAtFixed.scheduleWithFixedDelay(task.getClass().getName(), classBody, state, startTime, unit.toMillis(delay));
    addListener(result);
    return new RedissonScheduledFuture<Void>(result, startTime);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
@Override
public AutoDisposable schedule(Runnable task, long delay, TimeUnit unit) {
    if (!closed) {
        TrampolineTask tt = new TrampolineTask(task, unit.toMillis(delay));
        queue.offer(tt);
        drain();
        return tt;
    }
    return REJECTED;
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
private void addResponseSocketOpenTimeUrlParameter(SessionStatusRequest request, UriBuilder uriBuilder) {
  if (request.isResponseSocketOpenTimeSet()) {
    TimeUnit timeUnit = request.getResponseSocketOpenTimeUnit();
    long timeValue = request.getResponseSocketOpenTimeValue();
    long queryTimeoutInMilliseconds = timeUnit.toMillis(timeValue);
    uriBuilder.queryParam("timeoutMs", queryTimeoutInMilliseconds);
  }
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
@Override
public void setTimeout(long timeout, TimeUnit unit) {
    if (sseReader != null) {
        sseReader.setTimeout(timeout, unit);
    }
    readTimeoutMillis = unit.toMillis(timeout);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
private long checkTimeoutArgument(long timeout, TimeUnit unit) {
    if (timeout < 0) throw new IllegalArgumentException("timeout < 0");
    if (unit == null) throw new NullPointerException("unit == null");
    long millis = unit.toMillis(timeout);
    if (millis > Integer.MAX_VALUE)
        throw new IllegalArgumentException("Timeout too large.");
    if (millis == 0 && timeout > 0)
        throw new IllegalArgumentException("Timeout too small.");
    return millis;
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
/**
 * Polls the messages list for it to grow to a given minimum size at most timeout timeUnits and return a copy of
 * what we have so far.
 */
public List<String> getMessages(final int minSize, final long timeout, final TimeUnit timeUnit) throws InterruptedException {
    final long endMillis = System.currentTimeMillis() + timeUnit.toMillis(timeout);
    while (messages.size() < minSize && System.currentTimeMillis() < endMillis) {
        Thread.sleep(100);
    }
    return Collections.unmodifiableList(messages);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
public Cached(long cacheFor, TimeUnit timeUnit){
	this.cacheForMs = timeUnit.toMillis(cacheFor);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
public OkHttpResource readTimeout(long timeout, TimeUnit unit) {
  this.readTimeout = unit.toMillis(timeout);
  hasPerRequestReadTimeout = true;
  return this;
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
    long execTime = now() + unit.toMillis(delayTime);
    return enqueue(new SleepingAction(action, this, execTime), execTime);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
/**
 * Automatically flush when putting or invalidating if it's been more than
 * the given time period.
 */
public synchronized void setAutoFlush(long duration, TimeUnit unit)
{
	autoFlushDuration = unit.toMillis(duration);
}
 

import java.util.concurrent.TimeUnit; //导入方法依赖的package包/类
public static <T> ReplaySubject<T> createWithTimeAndSize(long time, TimeUnit unit, int size, Scheduler scheduler) {
    BoundedState<T> state = new BoundedState(new PairEvictionPolicy(new SizeEvictionPolicy(size), new TimeEvictionPolicy(unit.toMillis(time), scheduler)), new AddTimestamped(scheduler), new RemoveTimestamped());
    return createWithState(state, new TimedOnAdd(state, scheduler));
}