mirror of
https://github.com/jenkinsci/jenkins.git
synced 2026-11-18 06:22:29 +00:00
removed TimeUnit2, which is under GPL and hence incompatible.
git-svn-id: https://hudson.dev.java.net/svn/hudson/trunk/hudson/main@9497 71c3de6d-444a-0410-be80-ed276b4c234a
This commit is contained in:
1 parent
579c390ef6
commit
0b2c506dbd
3 files changed
+3
-540
No files matched your search
@@ -6,7 +6,6 @@ import java.util.WeakHashMap;
|
||||
import hudson.model.Computer;
|
||||
import hudson.model.Hudson;
|
||||
import hudson.triggers.SafeTimerTask;
|
||||
import hudson.util.TimeUnit2;
|
||||
|
||||
/**
|
||||
* Periodically checks the slaves and try to reconnect dead slaves.
|
||||
@@ -32,7 +31,7 @@ public class ComputerRetentionWork extends SafeTimerTask {
|
||||
// at the moment I don't trust strategies to wait more than 60 minutes
|
||||
// strategies need to wait at least one minute
|
||||
final long waitInMins = Math.min(1, Math.max(60, c.getRetentionStrategy().check(c)));
|
||||
nextCheck.put(c, startRun + TimeUnit2.MINUTES.toMillis(waitInMins));
|
||||
nextCheck.put(c, startRun + waitInMins*1000*60 /*MINS->MILLIS*/);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,10 +4,8 @@ import hudson.ExtensionPoint;
|
||||
import hudson.Util;
|
||||
import hudson.model.*;
|
||||
import hudson.util.DescriptorList;
|
||||
import hudson.util.TimeUnit2;
|
||||
import org.kohsuke.stapler.DataBoundConstructor;
|
||||
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.logging.Logger;
|
||||
import java.util.logging.Level;
|
||||
|
||||
@@ -153,7 +151,7 @@ public abstract class RetentionStrategy<T extends Computer> implements Describab
|
||||
public synchronized long check(SlaveComputer c) {
|
||||
if (c.isOffline()) {
|
||||
final long demandMilliseconds = System.currentTimeMillis() - c.getDemandStartMilliseconds();
|
||||
if (demandMilliseconds > TimeUnit2.MINUTES.toMillis(inDemandDelay)) {
|
||||
if (demandMilliseconds > inDemandDelay*1000*60 /*MINS->MILLIS*/) {
|
||||
// we've been in demand for long enough
|
||||
logger.log(Level.INFO, "Launching computer {0} as it has been in demand for {1}",
|
||||
new Object[]{c.getNode().getNodeName(), Util.getTimeSpanString(demandMilliseconds)});
|
||||
@@ -162,7 +160,7 @@ public abstract class RetentionStrategy<T extends Computer> implements Describab
|
||||
}
|
||||
} else if (c.isIdle()) {
|
||||
final long idleMilliseconds = System.currentTimeMillis() - c.getIdleStartMilliseconds();
|
||||
if (idleMilliseconds > TimeUnit2.MINUTES.toMillis(idleDelay)) {
|
||||
if (idleMilliseconds > idleDelay*1000*60 /*MINS->MILLIS*/) {
|
||||
// we've been idle for long enough
|
||||
logger.log(Level.INFO, "Disconnecting computer {0} as it has been idle for {1}",
|
||||
new Object[]{c.getNode().getNodeName(), Util.getTimeSpanString(idleMilliseconds)});
|
||||
|
||||
@@ -1,534 +0,0 @@
|
||||
/*
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation. Sun designates this
|
||||
* particular file as subject to the "Classpath" exception as provided
|
||||
* by Sun in the LICENSE file that accompanied this code.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
||||
* CA 95054 USA or visit www.sun.com if you need additional information or
|
||||
* have any questions.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file is available under and governed by the GNU General Public
|
||||
* License version 2 only, as published by the Free Software Foundation.
|
||||
* However, the following notice accompanied the original version of this
|
||||
* file:
|
||||
*
|
||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
||||
* Expert Group and released to the public domain, as explained at
|
||||
* http://creativecommons.org/licenses/publicdomain
|
||||
*/
|
||||
|
||||
package hudson.util;
|
||||
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
/**
|
||||
* Backport of TimeUnit from JDK 7.
|
||||
*
|
||||
* A <tt>TimeUnit</tt> represents time durations at a given unit of granularity and provides utility methods to convert
|
||||
* across units, and to perform timing and delay operations in these units. A <tt>TimeUnit</tt> does not maintain time
|
||||
* information, but only helps organize and use time representations that may be maintained separately across various
|
||||
* contexts. A nanosecond is defined as one thousandth of a microsecond, a microsecond as one thousandth of a
|
||||
* millisecond, a millisecond as one thousandth of a second, a minute as sixty seconds, an hour as sixty minutes, and a
|
||||
* day as twenty four hours.
|
||||
* <p/>
|
||||
* <p>A <tt>TimeUnit</tt> is mainly used to inform time-based methods how a given timing parameter should be
|
||||
* interpreted. For example, the following code will timeout in 50 milliseconds if the {@link
|
||||
* java.util.concurrent.locks.Lock lock} is not available:
|
||||
* <p/>
|
||||
* <pre> Lock lock = ...;
|
||||
* if ( lock.tryLock(50L, TimeUnit.MILLISECONDS) ) ...
|
||||
* </pre>
|
||||
* while this code will timeout in 50 seconds:
|
||||
* <pre>
|
||||
* Lock lock = ...;
|
||||
* if ( lock.tryLock(50L, TimeUnit.SECONDS) ) ...
|
||||
* </pre>
|
||||
* <p/>
|
||||
* Note however, that there is no guarantee that a particular timeout implementation will be able to notice the passage
|
||||
* of time at the same granularity as the given <tt>TimeUnit</tt>.
|
||||
*
|
||||
* @author Doug Lea
|
||||
* @since 1.5
|
||||
*/
|
||||
public enum TimeUnit2 {
|
||||
|
||||
NANOSECONDS {
|
||||
public long toNanos(long d) {
|
||||
return d;
|
||||
}
|
||||
public long toMicros(long d) {
|
||||
return d / (C1 / C0);
|
||||
}
|
||||
public long toMillis(long d) {
|
||||
return d / (C2 / C0);
|
||||
}
|
||||
public long toSeconds(long d) {
|
||||
return d / (C3 / C0);
|
||||
}
|
||||
public long toMinutes(long d) {
|
||||
return d / (C4 / C0);
|
||||
}
|
||||
public long toHours(long d) {
|
||||
return d / (C5 / C0);
|
||||
}
|
||||
public long toDays(long d) {
|
||||
return d / (C6 / C0);
|
||||
}
|
||||
public long convert(long d, TimeUnit2 u) {
|
||||
return u.toNanos(d);
|
||||
}
|
||||
public long convert(long d, TimeUnit u) {
|
||||
return u.toNanos(d);
|
||||
}
|
||||
int excessNanos(long d, long m) {
|
||||
return (int) (d - (m * C2));
|
||||
}
|
||||
},
|
||||
MICROSECONDS {
|
||||
public long toNanos(long d) {
|
||||
return x(d, C1 / C0, MAX / (C1 / C0));
|
||||
}
|
||||
public long toMicros(long d) {
|
||||
return d;
|
||||
}
|
||||
public long toMillis(long d) {
|
||||
return d / (C2 / C1);
|
||||
}
|
||||
public long toSeconds(long d) {
|
||||
return d / (C3 / C1);
|
||||
}
|
||||
public long toMinutes(long d) {
|
||||
return d / (C4 / C1);
|
||||
}
|
||||
public long toHours(long d) {
|
||||
return d / (C5 / C1);
|
||||
}
|
||||
public long toDays(long d) {
|
||||
return d / (C6 / C1);
|
||||
}
|
||||
public long convert(long d, TimeUnit2 u) {
|
||||
return u.toMicros(d);
|
||||
}
|
||||
public long convert(long d, TimeUnit u) {
|
||||
return u.toMicros(d);
|
||||
}
|
||||
int excessNanos(long d, long m) {
|
||||
return (int) ((d * C1) - (m * C2));
|
||||
}
|
||||
},
|
||||
MILLISECONDS {
|
||||
public long toNanos(long d) {
|
||||
return x(d, C2 / C0, MAX / (C2 / C0));
|
||||
}
|
||||
public long toMicros(long d) {
|
||||
return x(d, C2 / C1, MAX / (C2 / C1));
|
||||
}
|
||||
public long toMillis(long d) {
|
||||
return d;
|
||||
}
|
||||
public long toSeconds(long d) {
|
||||
return d / (C3 / C2);
|
||||
}
|
||||
public long toMinutes(long d) {
|
||||
return d / (C4 / C2);
|
||||
}
|
||||
public long toHours(long d) {
|
||||
return d / (C5 / C2);
|
||||
}
|
||||
public long toDays(long d) {
|
||||
return d / (C6 / C2);
|
||||
}
|
||||
public long convert(long d, TimeUnit2 u) {
|
||||
return u.toMillis(d);
|
||||
}
|
||||
public long convert(long d, TimeUnit u) {
|
||||
return u.toMillis(d);
|
||||
}
|
||||
int excessNanos(long d, long m) {
|
||||
return 0;
|
||||
}
|
||||
},
|
||||
SECONDS {
|
||||
public long toNanos(long d) {
|
||||
return x(d, C3 / C0, MAX / (C3 / C0));
|
||||
}
|
||||
public long toMicros(long d) {
|
||||
return x(d, C3 / C1, MAX / (C3 / C1));
|
||||
}
|
||||
public long toMillis(long d) {
|
||||
return x(d, C3 / C2, MAX / (C3 / C2));
|
||||
}
|
||||
public long toSeconds(long d) {
|
||||
return d;
|
||||
}
|
||||
public long toMinutes(long d) {
|
||||
return d / (C4 / C3);
|
||||
}
|
||||
public long toHours(long d) {
|
||||
return d / (C5 / C3);
|
||||
}
|
||||
public long toDays(long d) {
|
||||
return d / (C6 / C3);
|
||||
}
|
||||
public long convert(long d, TimeUnit2 u) {
|
||||
return u.toSeconds(d);
|
||||
}
|
||||
public long convert(long d, TimeUnit u) {
|
||||
return u.toSeconds(d);
|
||||
}
|
||||
int excessNanos(long d, long m) {
|
||||
return 0;
|
||||
}
|
||||
},
|
||||
MINUTES {
|
||||
public long toNanos(long d) {
|
||||
return x(d, C4 / C0, MAX / (C4 / C0));
|
||||
}
|
||||
public long toMicros(long d) {
|
||||
return x(d, C4 / C1, MAX / (C4 / C1));
|
||||
}
|
||||
public long toMillis(long d) {
|
||||
return x(d, C4 / C2, MAX / (C4 / C2));
|
||||
}
|
||||
public long toSeconds(long d) {
|
||||
return x(d, C4 / C3, MAX / (C4 / C3));
|
||||
}
|
||||
public long toMinutes(long d) {
|
||||
return d;
|
||||
}
|
||||
public long toHours(long d) {
|
||||
return d / (C5 / C4);
|
||||
}
|
||||
public long toDays(long d) {
|
||||
return d / (C6 / C4);
|
||||
}
|
||||
public long convert(long d, TimeUnit2 u) {
|
||||
return u.toMinutes(d);
|
||||
}
|
||||
public long convert(long d, TimeUnit u) {
|
||||
return SECONDS.toMinutes(u.toSeconds(d));
|
||||
}
|
||||
int excessNanos(long d, long m) {
|
||||
return 0;
|
||||
}
|
||||
},
|
||||
HOURS {
|
||||
public long toNanos(long d) {
|
||||
return x(d, C5 / C0, MAX / (C5 / C0));
|
||||
}
|
||||
public long toMicros(long d) {
|
||||
return x(d, C5 / C1, MAX / (C5 / C1));
|
||||
}
|
||||
public long toMillis(long d) {
|
||||
return x(d, C5 / C2, MAX / (C5 / C2));
|
||||
}
|
||||
public long toSeconds(long d) {
|
||||
return x(d, C5 / C3, MAX / (C5 / C3));
|
||||
}
|
||||
public long toMinutes(long d) {
|
||||
return x(d, C5 / C4, MAX / (C5 / C4));
|
||||
}
|
||||
public long toHours(long d) {
|
||||
return d;
|
||||
}
|
||||
public long toDays(long d) {
|
||||
return d / (C6 / C5);
|
||||
}
|
||||
public long convert(long d, TimeUnit2 u) {
|
||||
return u.toHours(d);
|
||||
}
|
||||
public long convert(long d, TimeUnit u) {
|
||||
return SECONDS.toHours(u.toSeconds(d));
|
||||
}
|
||||
int excessNanos(long d, long m) {
|
||||
return 0;
|
||||
}
|
||||
},
|
||||
DAYS {
|
||||
public long toNanos(long d) {
|
||||
return x(d, C6 / C0, MAX / (C6 / C0));
|
||||
}
|
||||
public long toMicros(long d) {
|
||||
return x(d, C6 / C1, MAX / (C6 / C1));
|
||||
}
|
||||
public long toMillis(long d) {
|
||||
return x(d, C6 / C2, MAX / (C6 / C2));
|
||||
}
|
||||
public long toSeconds(long d) {
|
||||
return x(d, C6 / C3, MAX / (C6 / C3));
|
||||
}
|
||||
public long toMinutes(long d) {
|
||||
return x(d, C6 / C4, MAX / (C6 / C4));
|
||||
}
|
||||
public long toHours(long d) {
|
||||
return x(d, C6 / C5, MAX / (C6 / C5));
|
||||
}
|
||||
public long toDays(long d) {
|
||||
return d;
|
||||
}
|
||||
public long convert(long d, TimeUnit2 u) {
|
||||
return u.toDays(d);
|
||||
}
|
||||
public long convert(long d, TimeUnit u) {
|
||||
return SECONDS.toDays(u.toSeconds(d));
|
||||
}
|
||||
int excessNanos(long d, long m) {
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
// Handy constants for conversion methods
|
||||
static final long C0 = 1L;
|
||||
static final long C1 = C0 * 1000L;
|
||||
static final long C2 = C1 * 1000L;
|
||||
static final long C3 = C2 * 1000L;
|
||||
static final long C4 = C3 * 60L;
|
||||
static final long C5 = C4 * 60L;
|
||||
static final long C6 = C5 * 24L;
|
||||
|
||||
static final long MAX = Long.MAX_VALUE;
|
||||
|
||||
/**
|
||||
* Scale d by m, checking for overflow. This has a short name to make above code more readable.
|
||||
*/
|
||||
static long x(long d, long m, long over) {
|
||||
if (d > over) return Long.MAX_VALUE;
|
||||
if (d < -over) return Long.MIN_VALUE;
|
||||
return d * m;
|
||||
}
|
||||
|
||||
// To maintain full signature compatibility with 1.5, and to improve the
|
||||
// clarity of the generated javadoc (see 6287639: Abstract methods in
|
||||
// enum classes should not be listed as abstract), method convert
|
||||
// etc. are not declared abstract but otherwise act as abstract methods.
|
||||
|
||||
/**
|
||||
* Convert the given time duration in the given unit to this unit. Conversions from finer to coarser granularities
|
||||
* truncate, so lose precision. For example converting <tt>999</tt> milliseconds to seconds results in <tt>0</tt>.
|
||||
* Conversions from coarser to finer granularities with arguments that would numerically overflow saturate to
|
||||
* <tt>Long.MIN_VALUE</tt> if negative or <tt>Long.MAX_VALUE</tt> if positive.
|
||||
* <p/>
|
||||
* <p>For example, to convert 10 minutes to milliseconds, use: <tt>TimeUnit.MILLISECONDS.convert(10L,
|
||||
* TimeUnit.MINUTES)</tt>
|
||||
*
|
||||
* @param sourceDuration the time duration in the given <tt>sourceUnit</tt>
|
||||
* @param sourceUnit the unit of the <tt>sourceDuration</tt> argument
|
||||
*
|
||||
* @return the converted duration in this unit, or <tt>Long.MIN_VALUE</tt> if conversion would negatively overflow,
|
||||
* or <tt>Long.MAX_VALUE</tt> if it would positively overflow.
|
||||
*/
|
||||
public long convert(long sourceDuration, TimeUnit2 sourceUnit) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert the given time duration in the given unit to this unit. Conversions from finer to coarser granularities
|
||||
* truncate, so lose precision. For example converting <tt>999</tt> milliseconds to seconds results in <tt>0</tt>.
|
||||
* Conversions from coarser to finer granularities with arguments that would numerically overflow saturate to
|
||||
* <tt>Long.MIN_VALUE</tt> if negative or <tt>Long.MAX_VALUE</tt> if positive.
|
||||
* <p/>
|
||||
* <p>For example, to convert 10 minutes to milliseconds, use: <tt>TimeUnit.MILLISECONDS.convert(10L,
|
||||
* TimeUnit.MINUTES)</tt>
|
||||
*
|
||||
* @param sourceDuration the time duration in the given <tt>sourceUnit</tt>
|
||||
* @param sourceUnit the unit of the <tt>sourceDuration</tt> argument
|
||||
*
|
||||
* @return the converted duration in this unit, or <tt>Long.MIN_VALUE</tt> if conversion would negatively overflow,
|
||||
* or <tt>Long.MAX_VALUE</tt> if it would positively overflow.
|
||||
*/
|
||||
public long convert(long sourceDuration, TimeUnit sourceUnit) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Equivalent to <tt>NANOSECONDS.convert(duration, this)</tt>.
|
||||
*
|
||||
* @param duration the duration
|
||||
*
|
||||
* @return the converted duration, or <tt>Long.MIN_VALUE</tt> if conversion would negatively overflow, or
|
||||
* <tt>Long.MAX_VALUE</tt> if it would positively overflow.
|
||||
*
|
||||
* @see #convert
|
||||
*/
|
||||
public long toNanos(long duration) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Equivalent to <tt>MICROSECONDS.convert(duration, this)</tt>.
|
||||
*
|
||||
* @param duration the duration
|
||||
*
|
||||
* @return the converted duration, or <tt>Long.MIN_VALUE</tt> if conversion would negatively overflow, or
|
||||
* <tt>Long.MAX_VALUE</tt> if it would positively overflow.
|
||||
*
|
||||
* @see #convert
|
||||
*/
|
||||
public long toMicros(long duration) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Equivalent to <tt>MILLISECONDS.convert(duration, this)</tt>.
|
||||
*
|
||||
* @param duration the duration
|
||||
*
|
||||
* @return the converted duration, or <tt>Long.MIN_VALUE</tt> if conversion would negatively overflow, or
|
||||
* <tt>Long.MAX_VALUE</tt> if it would positively overflow.
|
||||
*
|
||||
* @see #convert
|
||||
*/
|
||||
public long toMillis(long duration) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Equivalent to <tt>SECONDS.convert(duration, this)</tt>.
|
||||
*
|
||||
* @param duration the duration
|
||||
*
|
||||
* @return the converted duration, or <tt>Long.MIN_VALUE</tt> if conversion would negatively overflow, or
|
||||
* <tt>Long.MAX_VALUE</tt> if it would positively overflow.
|
||||
*
|
||||
* @see #convert
|
||||
*/
|
||||
public long toSeconds(long duration) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Equivalent to <tt>MINUTES.convert(duration, this)</tt>.
|
||||
*
|
||||
* @param duration the duration
|
||||
*
|
||||
* @return the converted duration, or <tt>Long.MIN_VALUE</tt> if conversion would negatively overflow, or
|
||||
* <tt>Long.MAX_VALUE</tt> if it would positively overflow.
|
||||
*
|
||||
* @see #convert
|
||||
* @since 1.6
|
||||
*/
|
||||
public long toMinutes(long duration) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Equivalent to <tt>HOURS.convert(duration, this)</tt>.
|
||||
*
|
||||
* @param duration the duration
|
||||
*
|
||||
* @return the converted duration, or <tt>Long.MIN_VALUE</tt> if conversion would negatively overflow, or
|
||||
* <tt>Long.MAX_VALUE</tt> if it would positively overflow.
|
||||
*
|
||||
* @see #convert
|
||||
* @since 1.6
|
||||
*/
|
||||
public long toHours(long duration) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Equivalent to <tt>DAYS.convert(duration, this)</tt>.
|
||||
*
|
||||
* @param duration the duration
|
||||
*
|
||||
* @return the converted duration
|
||||
*
|
||||
* @see #convert
|
||||
* @since 1.6
|
||||
*/
|
||||
public long toDays(long duration) {
|
||||
throw new AbstractMethodError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility to compute the excess-nanosecond argument to wait, sleep, join.
|
||||
*
|
||||
* @param d the duration
|
||||
* @param m the number of milliseconds
|
||||
*
|
||||
* @return the number of nanoseconds
|
||||
*/
|
||||
abstract int excessNanos(long d, long m);
|
||||
|
||||
/**
|
||||
* Performs a timed <tt>Object.wait</tt> using this time unit. This is a convenience method that converts timeout
|
||||
* arguments into the form required by the <tt>Object.wait</tt> method.
|
||||
* <p/>
|
||||
* <p>For example, you could implement a blocking <tt>poll</tt> method (see {@link java.util.concurrent.BlockingQueue#poll
|
||||
* BlockingQueue.poll}) using:
|
||||
* <p/>
|
||||
* <pre> public synchronized Object poll(long timeout, TimeUnit unit) throws InterruptedException {
|
||||
* while (empty) {
|
||||
* unit.timedWait(this, timeout);
|
||||
* ...
|
||||
* }
|
||||
* }</pre>
|
||||
*
|
||||
* @param obj the object to wait on
|
||||
* @param timeout the maximum time to wait. If less than or equal to zero, do not wait at all.
|
||||
*
|
||||
* @throws InterruptedException if interrupted while waiting.
|
||||
* @see Object#wait(long, int)
|
||||
*/
|
||||
public void timedWait(Object obj, long timeout)
|
||||
throws InterruptedException {
|
||||
if (timeout > 0) {
|
||||
long ms = toMillis(timeout);
|
||||
int ns = excessNanos(timeout, ms);
|
||||
obj.wait(ms, ns);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a timed <tt>Thread.join</tt> using this time unit. This is a convenience method that converts time
|
||||
* arguments into the form required by the <tt>Thread.join</tt> method.
|
||||
*
|
||||
* @param thread the thread to wait for
|
||||
* @param timeout the maximum time to wait. If less than or equal to zero, do not wait at all.
|
||||
*
|
||||
* @throws InterruptedException if interrupted while waiting.
|
||||
* @see Thread#join(long, int)
|
||||
*/
|
||||
public void timedJoin(Thread thread, long timeout)
|
||||
throws InterruptedException {
|
||||
if (timeout > 0) {
|
||||
long ms = toMillis(timeout);
|
||||
int ns = excessNanos(timeout, ms);
|
||||
thread.join(ms, ns);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a <tt>Thread.sleep</tt> using this unit. This is a convenience method that converts time arguments into
|
||||
* the form required by the <tt>Thread.sleep</tt> method.
|
||||
*
|
||||
* @param timeout the minimum time to sleep. If less than or equal to zero, do not sleep at all.
|
||||
*
|
||||
* @throws InterruptedException if interrupted while sleeping.
|
||||
* @see Thread#sleep
|
||||
*/
|
||||
public void sleep(long timeout) throws InterruptedException {
|
||||
if (timeout > 0) {
|
||||
long ms = toMillis(timeout);
|
||||
int ns = excessNanos(timeout, ms);
|
||||
Thread.sleep(ms, ns);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user