java.util.concurrent.TimeUnit 枚舉源碼

時間 2019-11-13

標籤 java.util.concurrent.timeunit java util concurrent timeunit 枚舉源碼欄目 Java 简体版

原文原文鏈接

線程池相關

源碼：

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

全部已實現的接口：html

Serializable, Comparable< TimeUnit>java

TimeUnit 表示給定單元粒度的時間段，它提供在這些單元中進行跨單元轉換和執行計時及延遲操做的實用工具方法。api

TimeUnit 不維護時間信息，可是有助於組織和使用可能跨各類上下文單獨維護的時間表示形式。毫微秒定義爲千分之一微秒，微秒爲千分之一毫秒，毫秒爲千分之一秒，一分鐘爲六十秒，一小時爲六十分鐘，一天爲二十四小時。數組

TimeUnit 主要用於通知基於時間的方法如何解釋給定的計時參數。工具

例如，對於lock內置鎖，若是獲取鎖在指定時間50毫秒失敗，則超時返回：this

  Lock lock = ...;
  if (lock.tryLock(50L, TimeUnit.MILLISECONDS)){//獲取鎖成功
     ...//則執行
  }

從類 java.lang.Enum 繼承的方法spa

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

從類 java.lang.Object 繼承的方法線程

getClass, notify, notifyAll, wait, wait, waitcode

枚舉常量

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)

相關標籤/搜索

枚舉

java.util.concurrent.timeunit

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

java.util.concurrent.TimeUnit 枚舉 源碼

線程池相關

源碼：

枚舉 TimeUnit

values

valueOf

convert

toNanos

toMicros

toMillis

toSeconds

toMinutes

toHours

toDays

timedWait

timedJoin

sleep

java.util.concurrent.TimeUnit 枚舉源碼