深入学习java源码之TimeUnit.sleep()与TimeUnit.timedWait()

深入学习java源码之TimeUnit.sleep()与TimeUnit.timedWait()

TimeUnit是java.util.concurrent包下面的一个类，TimeUnit提供了可读性更好的线程暂停操作，通常用来替换Thread.sleep()，在很长一段时间里Thread的sleep()方法作为暂停线程的标准方式，几乎所有Java程序员都熟悉它，事实上sleep方法本身也很常用而且出现在很多面试中。如果你已经使用过Thread.sleep()，当然我确信你这样做过，那么你一定熟知它是一个静态方法，暂停线程时它不会释放锁，该方法会抛出InterrupttedException异常（如果有线程中断了当前线程）。但是我们很多人并没有注意的一个潜在的问题就是它的可读性。Thread.sleep()是一个重载方法，可以接收长整型毫秒和长整型的纳秒参数，这样对程序员造成的一个问题就是很难知道到底当前线程是睡眠了多少秒、分、小时或者天。看看下面这个Thread.sleep()方法：

Thread.sleep（2400000）

粗略一看，你能计算出当前线程是等待多长时间吗？可能有些人可以，但是对于大多数程序员来说这种写法的可读性还是很差的，你需要把毫秒转换成秒和分，让我们来看看另外一个例子，这个例子比前面那个例子可读性稍微好一点：

Thread.sleep(4*60*1000);

这比前面那个例子已经好多了，但是仍然不是最好的，你注意到睡眠时间用毫秒，不容易猜出当前线程将等待4分钟。TimeUnit类解决了这个问题，通过指定DAYS、HOURS、MINUTES,SECONDS、MILLISECONDS和NANOSECONDS。java.utils.concurrent .TimeUnit 是Java枚举应用场景中最好的例子之一，所有TimeUnit都是枚举实例，让我们来看看线程睡眠4分钟用TimeUnit是如何使用的。

TimeUnit.MINUTES.sleep(4);  // sleeping for 4 minutes

类似你可以采用秒、分、小时级别来暂停当前线程。你可以看到这比Thread的sleep方法的可读的好多了。记住TimeUnit.sleep()内部调用的Thread.sleep()也会抛出InterruptException。你也可以查看JDK源代码去验证一下。下面是一个简单例子，它展示如果使用TimeUnit.sleep()方法。

public class TimeUnitTest {
 
    public static void main(String args[]) throws InterruptedException {
 
        System.out.println("Sleeping for 4 minutes using Thread.sleep()");
        Thread.sleep(4 * 60 * 1000);
        System.out.println("Sleeping for 4 minutes using TimeUnit sleep()");
 
        TimeUnit.SECONDS.sleep(4);
        TimeUnit.MINUTES.sleep(4);
        TimeUnit.HOURS.sleep(1);
        TimeUnit.DAYS.sleep(1);
    }
}

除了sleep的功能外，TimeUnit还提供了便捷方法用于把时间转换成不同单位，例如，如果你想把秒转换成毫秒，你可以使用下面代码：

TimeUnit.SECONDS.toMillis(44)

它将返回44,000

TimeUnit vs Thread.sleep()

目前我们讨论使用TimeUnit的好处是提高了可读性，但是有时候觉得其他方法更好，因为Thread.sleep()伴随java很早就出现了，几乎所有程序员都知道Thread.sleep()，都知道是将当前线程暂停，而对TimeUnit并不太熟悉。两个原因：一是对比起Thread.sleep()，TimeUnit不是很常用，第二是在它不在Thread类中，就像wait和notify同样不是在Thread中，反正这些需要一段时间才能被采用,并成为一个标准的方式。

总结来说在你想用Thread.sleep()方法的地方你最好使用TimeUnit.sleep()方法来代替。它不尽可以提高代码的可读性而且能更加熟悉java.util.concurrent包，因为TimeUnit在并发编程中也是一个关键API。

//关于秒的常用方法 
TimeUnit.SECONDS.toMillis(1) 1秒转换为毫秒数 
TimeUnit.SECONDS.toMinutes(60) 60秒转换为分钟数 
TimeUnit.SECONDS.sleep(5) 线程休眠5秒 
TimeUnit.SECONDS.convert(1, TimeUnit.MINUTES) 1分钟转换为秒数 

//TimeUnit.DAYS 日的工具类 
//TimeUnit.HOURS 时的工具类 
//TimeUnit.MINUTES 分的工具类 
//TimeUnit.SECONDS 秒的工具类 
//TimeUnit.MILLISECONDS 毫秒的工具类

 1 import java.util.concurrent.TimeUnit;
 2  
 3 public class TimeUnitDemo {
 4      private TimeUnit timeUnit =TimeUnit.DAYS;
 5  
 6      public static void main(String[] args) {
 7         TimeUnitDemo demo = new TimeUnitDemo();
 8         demo.outInfo();
 9         demo.timeUnit =TimeUnit.HOURS;
10         demo.outInfo();
11         demo.timeUnit =TimeUnit.MINUTES;
12         demo.outInfo();
13         demo.timeUnit =TimeUnit.SECONDS;
14         demo.outInfo();
15     }
16 
17     public void outInfo() {
18         System.out.println(timeUnit.name());
19         System.out.println(timeUnit.toDays(1));
20         System.out.println(timeUnit.toHours(1));
21         System.out.println(timeUnit.toMinutes(1));
22         System.out.println(timeUnit.toMicros(1));
23         System.out.println(timeUnit.toMillis(1));
24         System.out.println(timeUnit.toNanos(1));
25         System.out.println(timeUnit.toSeconds(1));
26         System.out.println("1天有"+(timeUnit.convert(1, TimeUnit.DAYS))+timeUnit.name());
27         System.out.println("12小时"+(timeUnit.convert(12, TimeUnit.HOURS))+timeUnit.name());
28         System.out.println("3600秒有"+(timeUnit.convert(36000, TimeUnit.MINUTES))+timeUnit.name());
29         System.out.println("-------------------");
30     }
31 }

 

java源码

A TimeUnit表示给定的粒度单位的持续时间，并且提供了跨单元转换的实用方法，并且在这些单元中执行定时和延迟操作。 A TimeUnit不保留时间信息，但只能帮助组织和使用可能在不同上下文中单独维护的时间表示。 一纳秒定义为千分之一秒，微秒为千分之一毫秒，毫秒为千分之一秒，一分钟为六十秒，一小时为六十分钟，一天为二十四小时。

 

Enum Constant and DescriptionDAYS

时间单位代表二十四小时

HOURS

时间单位代表六十分钟

MICROSECONDS

时间单位代表千分之一毫秒

MILLISECONDS

时间单位为千分之一秒

MINUTES

时间单位代表60秒

NANOSECONDS

时间单位代表千分之一千分之一

SECONDS

时间单位代表一秒

 

Modifier and TypeMethod and Descriptionlongconvert(long sourceDuration, TimeUnit sourceUnit)

将给定单位的给定持续时间转换为本机。

voidsleep(long timeout)

使用此时间单位执行 Thread.sleep 。

voidtimedJoin(Thread thread, long timeout)

使用此时间单位执行定时 Thread.join 。

voidtimedWait(Object obj, long timeout)

使用此时间单位执行定时的 Object.wait 。

longtoDays(long duration)

相当于 DAYS.convert(duration, this) 。

longtoHours(long duration)

相当于 HOURS.convert(duration, this) 。

longtoMicros(long duration)

相当于 MICROSECONDS.convert(duration, this) 。

longtoMillis(long duration)

相当于 MILLISECONDS.convert(duration, this) 。

longtoMinutes(long duration)

相当于 MINUTES.convert(duration, this) 。

longtoNanos(long duration)

相当于 NANOSECONDS.convert(duration, this) 。

longtoSeconds(long duration)

相当于 SECONDS.convert(duration, this) 。

static TimeUnitvalueOf(String name)

以指定的名称返回此类型的枚举常量。

static TimeUnit[]values()

按照它们声明的顺序返回一个包含此枚举类型常量的数组。

package java.util.concurrent;

public enum TimeUnit {

    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, 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, 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, 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, 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, TimeUnit u) { return u.toMinutes(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, TimeUnit u) { return u.toHours(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, TimeUnit u) { return u.toDays(d); }
        int excessNanos(long d, long m) { return 0; }
    };

    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;

    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;
    }
	
    public long convert(long sourceDuration, TimeUnit sourceUnit) {
        throw new AbstractMethodError();
    }

    public long toNanos(long duration) {
        throw new AbstractMethodError();
    }

    public long toMicros(long duration) {
        throw new AbstractMethodError();
    }

    public long toMillis(long duration) {
        throw new AbstractMethodError();
    }

    public long toSeconds(long duration) {
        throw new AbstractMethodError();
    }

    public long toMinutes(long duration) {
        throw new AbstractMethodError();
    }

    public long toHours(long duration) {
        throw new AbstractMethodError();
    }

    public long toDays(long duration) {
        throw new AbstractMethodError();
    }

    abstract int excessNanos(long d, long m);

    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);
        }
    }

    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);
        }
    }

    public void sleep(long timeout) throws InterruptedException {
        if (timeout > 0) {
            long ms = toMillis(timeout);
            int ns = excessNanos(timeout, ms);
            Thread.sleep(ms, ns);
        }
    }

}