java.util.concurrent.TimeUnit 枚举源码

最新推荐文章于 2023-04-19 13:13:15 发布

weixin_34292402

最新推荐文章于 2023-04-19 13:13:15 发布

阅读量160

点赞数

文章标签： java python

原文链接：https://my.oschina.net/langwanghuangshifu/blog/2962031

版权

2019独角兽企业重金招聘Python工程师标准>>>

线程池相关

源码：

package java.util.concurrent;

public enum TimeUnit {
    //1纳秒
    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)); }
    },

    //1微秒
    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)); }
    },

    //1毫秒
    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; }
    },

   //1秒
    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; }
    },

   //1分钟
    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; }
    },

   //1小时
    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; }
    },

    //1天
    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;//1纳秒
    static final long C1 = C0 * 1000L;//1微秒
    static final long C2 = C1 * 1000L;//1毫秒
    static final long C3 = C2 * 1000L;//1秒
    static final long C4 = C3 * 60L;//1分
    static final long C5 = C4 * 60L;//1小时
    static final long C6 = C5 * 24L;//1天

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

    abstract int excessNanos(long d, long m);

    //将给定单元的时间段转换到此单元
    public long convert(long sourceDuration, TimeUnit sourceUnit) {
        throw new AbstractMethodError();
    }

    //等效于 NANOSECONDS.convert(duration, this)
    public long toNanos(long duration) {
        throw new AbstractMethodError();
    }

    //等效于 MICROSECONDS.convert(duration, this)
    public long toMicros(long duration) {
        throw new AbstractMethodError();
    }

    //等效于 MILLISECONDS.convert(duration, this)
    public long toMillis(long duration) {
        throw new AbstractMethodError();
    }

    //等效于 SECONDS.convert(duration, this)
    public long toSeconds(long duration) {
        throw new AbstractMethodError();
    }

    //等效于 MINUTES.convert(duration, this)
    public long toMinutes(long duration) {
        throw new AbstractMethodError();
    }

    //等效于 HOURS.convert(duration, this)
    public long toHours(long duration) {
        throw new AbstractMethodError();
    }

    //等效于 DAYS.convert(duration, this)
    public long toDays(long duration) {
        throw new AbstractMethodError();
    }

    //使用此时间单元执行计时的 Object.wait
    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);
        }
    }

    //使用此时间单元执行计时的 Thread.join
    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);
        }
    }

    //使用此单元执行 Thread.sleep.这是将时间参数转换为 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);
        }
    }

}

枚举 TimeUnit

所有已实现的接口：

Serializable, Comparable< TimeUnit>

TimeUnit 表示给定单元粒度的时间段，它提供在这些单元中进行跨单元转换和执行计时及延迟操作的实用工具方法。

TimeUnit 不维护时间信息，但是有助于组织和使用可能跨各种上下文单独维护的时间表示形式。毫微秒定义为千分之一微秒，微秒为千分之一毫秒，毫秒为千分之一秒，一分钟为六十秒，一小时为六十分钟，一天为二十四小时。

TimeUnit 主要用于通知基于时间的方法如何解释给定的计时参数。

例如，对于lock内置锁，如果获取锁在指定时间50毫秒失败，则超时返回：

  Lock lock = ...;
  if (lock.tryLock(50L, TimeUnit.MILLISECONDS)){//获取锁成功
     ...//则执行
  }

从类 java.lang.Enum 继承的方法

clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

从类 java.lang.Object 继承的方法

getClass, notify, notifyAll, wait, wait, wait

枚举常量

NANOSECONDS
MICROSECONDS
MILLISECONDS
SECONDS
MINUTES
HOURS
DAYS

values

public static final TimeUnit[] values()

返回包含该枚举类型的常量的数组，按照它们声明的顺序。此方法可用于迭代常数，如下所示:

for(TimeUnit c : TimeUnit.values())
        System.out.println(c);

valueOf

public static TimeUnit valueOf(String name)

返回带有指定名称的该类型的枚举常量。字符串必须与用于声明该类型的枚举常量的标识符完全匹配。（不允许有多余的空格。）

参数：

指定要返回的枚举常量的名称。

返回：

返回带有指定名称的枚举常量

抛出：

如果该枚举类型没有带有指定名称的常量， - 则抛出 IllegalArgumentException

convert

public long convert(long sourceDuration,TimeUnit sourceUnit)

将给定单元的时间段转换到此单元。从较细粒度到较粗粒度的舍位转换，这样会失去精确性。例如，将 999 毫秒转换为秒的结果为 0。使用参数从较粗粒度到较细粒度转换，如果参数为负，则在数字上溢出至Long.MIN_VALUE，如果为正，则为 Long.MAX_VALUE。

例如，要将 10 分钟转换为毫秒，请使用：TimeUnit.MILLISECONDS.convert(10L, TimeUnit.MINUTES)

参数：

sourceDuration - 给定 sourceUnit 中的时间段

sourceUnit - sourceDuration 参数的单元

返回：

此单元中的转换时间段；如果转换将负溢出，则返回 Long.MIN_VALUE；如果转换将正溢出，则返回 Long.MAX_VALUE。

toNanos

public long toNanos(long duration)

等效于 NANOSECONDS.convert(duration, this)。

参数：

duration - 时间段

返回：

转换时间段，如果转换将负溢出，则返回 Long.MIN_VALUE；如果转换将正溢出，则返回 Long.MAX_VALUE。

另请参见：

convert(long, java.util.concurrent.TimeUnit)

toMicros

public long toMicros(long duration)

等效于 MICROSECONDS.convert(duration, this)。

参数：

duration - 时间段

返回：

转换时间段，如果转换将负溢出，则返回 Long.MIN_VALUE；如果转换将正溢出，则返回 Long.MAX_VALUE。

另请参见：

convert(long, java.util.concurrent.TimeUnit)

toMillis

public long toMillis(long duration)

等效于 MILLISECONDS.convert(duration, this)。

参数：

duration - 时间段

返回：

转换时间段，如果转换将负溢出，则返回 Long.MIN_VALUE；如果转换将正溢出，则返回 Long.MAX_VALUE。

另请参见：

convert(long, java.util.concurrent.TimeUnit)

toSeconds

public long toSeconds(long duration)

等效于 SECONDS.convert(duration, this)。

参数：

duration - 时间段

返回：

转换时间段；如果转换将负溢出，则返回 Long.MIN_VALUE；如果转换将正溢出，则返回 Long.MAX_VALUE。

另请参见：

convert(long, java.util.concurrent.TimeUnit)

toMinutes

public long toMinutes(long duration)

等效于 MINUTES.convert(duration, this)。

参数：

duration - 时间段

返回：

转换时间段；如果转换将负溢出，则返回 Long.MIN_VALUE；如果转换将正溢出，则返回 Long.MAX_VALUE。

另请参见：

convert(long, java.util.concurrent.TimeUnit)

toHours

public long toHours(long duration)

等效于 HOURS.convert(duration, this)。

参数：

duration - 时间段

返回：

转换时间段；如果转换将负溢出，则返回 Long.MIN_VALUE；如果转换将正溢出，则返回 Long.MAX_VALUE。

另请参见：

convert(long, java.util.concurrent.TimeUnit)

toDays

public long toDays(long duration)

等效于 DAYS.convert(duration, this)。

参数：

duration - 时间段

返回：

转换时间段

另请参见：

convert(long, java.util.concurrent.TimeUnit)

timedWait

public void timedWait(Object obj,long timeout) throws InterruptedException

使用此时间单元执行计时的 Object.wait。这是将超时参数转换为 Object.wait 方法所需格式的便捷方法。

例如，可以使用以下代码实现阻塞 poll 方法（参见 BlockingQueue.poll）：

  public synchronized  Object poll(long timeout, TimeUnit unit) throws InterruptedException {
    while (empty) {
      unit.timedWait(this, timeout);
      ...
    }
  }

参数：

obj - 要等待的对象

timeout - 要等待的最长时间。如果小于等于 0，则根本不会等待。

抛出：

InterruptedException - 如果等待时中断。

另请参见：

Object.wait(long, int)

timedJoin

public void timedJoin(Thread thread,long timeout) throws InterruptedException

使用此时间单元执行计时的 Thread.join。这是将时间参数转换为 Thread.join 方法所需格式的便捷方法。

参数：

thread - 要等待的线程

timeout - 要等待的最长时间。如果小于等于 0，则根本不会等待。

抛出：

InterruptedException - 如果等待时中断。

另请参见：

Thread.join(long, int)

sleep

public void sleep(long timeout) throws InterruptedException

使用此单元执行 Thread.sleep.这是将时间参数转换为 Thread.sleep 方法所需格式的便捷方法。

参数：

timeout - 休眠的最短时间。如果小于等于 0，则根本不会休眠。

抛出：

InterruptedException - 如果休眠时中断。

另请参见：

Thread.sleep(long)

转载于:https://my.oschina.net/langwanghuangshifu/blog/2962031

weixin_34292402

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java.util.concurrent.TimeUnit 枚举源码

2019独角兽企业重金招聘Python工程师标准>>> ...
复制链接

扫一扫

java.util.concurrent.TimeUnit 枚举 源码

线程池相关

源码：

枚举 TimeUnit

values

valueOf

convert

toNanos

toMicros

toMillis

toSeconds

toMinutes

toHours

toDays

timedWait

timedJoin

sleep

java.util.concurrent.TimeUnit 枚举源码