2. 程式人生 > >java.util.concurrent.TimeUnit 列舉 原始碼

java.util.concurrent.TimeUnit 列舉 原始碼

阿新 • • 發佈：2018-11-28

執行緒池相關

原始碼：

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

}

列舉 TimeUnit

所有已實現的介面：

    Serializable, Comparable< TimeUnit>

    TimeUnit 表示給定單元粒度的時間段，它提供在這些單元中進行跨單元轉換和執行計時及延遲操作的實用工具方法。TimeUnit 不維護時間資訊，但是有助於組織和使用可能跨各種上下文單獨維護的時間表示形式。毫微秒定義為千分之一微秒，微秒為千分之一毫秒，毫秒為千分之一秒，一分鐘為六十秒，一小時為六十分鐘，一天為二十四小時。

    TimeUnit 主要用於通知基於時間的方法如何解釋給定的計時引數。例如，如果 lock 不可用，則以下程式碼將在 50 毫秒後超時：

  Lock lock = ...;
  if ( lock.tryLock(50L, TimeUnit.MILLISECONDS) ) ...

    而以下程式碼將在 50 秒後超時：

  Lock lock = ...;
  if ( lock.tryLock(50L, TimeUnit.SECONDS) ) ...

 

列舉常量摘要
DAYS 
           
HOURS 
           
MICROSECONDS 
           
MILLISECONDS 
           
MINUTES 
           
NANOSECONDS 
           
SECONDS 
           

 

方法摘要

 long convert(long sourceDuration, TimeUnit sourceUnit) 
          將給定單元的時間段轉換到此單元。
 void sleep(long timeout) 
          使用此單元執行 Thread.sleep.這是將時間引數轉換為 Thread.sleep 方法所需格式的便捷方法。
 void timedJoin(Thread thread, long timeout) 
          使用此時間單元執行計時的 Thread.join。
 void timedWait(Object obj, long timeout) 
          使用此時間單元執行計時的 Object.wait。
 long toDays(long duration) 
          等效於 DAYS.convert(duration, this)。
 long toHours(long duration) 
          等效於 HOURS.convert(duration, this)。
 long toMicros(long duration) 
          等效於 MICROSECONDS.convert(duration, this)。
 long toMillis(long duration) 
          等效於 MILLISECONDS.convert(duration, this)。
 long toMinutes(long duration) 
          等效於 MINUTES.convert(duration, this)。
 long toNanos(long duration) 
          等效於 NANOSECONDS.convert(duration, this)。
 long toSeconds(long duration) 
          等效於 SECONDS.convert(duration, this)。
static TimeUnit valueOf(String name) 
          返回帶有指定名稱的該型別的列舉常量。
static TimeUnit[] values() 
          Returns an array containing the constants of this enum type, in the order they are declared.

 從類 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)

相關推薦

java.util.concurrent.TimeUnit 列舉 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public enum TimeUnit { NANOSECONDS { public long toNanos(long d) { return

java.util.concurrent.Executor 介面 原始碼

執行緒池相關 原始碼： public interface Executor { void execute(Runnable command); } 介面 Executor 已知子介面：     Execu

java.util.concurrent.ScheduledExecutorService 介面 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public interface ScheduledExecutorService extends ExecutorService { //建立並執行在給定延遲後啟用的一次性

java.util.concurrent.Future 介面 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public interface Future<V> { boolean cancel(boolean mayInterruptIfRunning);

java.util.concurrent.CompletionService 介面 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public interface CompletionService<V> { Future<V> submit(Callable<

java.util.concurrent.Delayed 介面 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public interface Delayed extends Comparable<Delayed> { //返回與此物件相關的剩餘延遲時間，以給定的時間單位

java.util.concurrent.RunnableScheduledFuture 介面 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public interface RunnableScheduledFuture<V> extends RunnableFuture<V>, Scheduled

java.util.concurrent.ScheduledFuture 介面 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public interface ScheduledFuture<V> extends Delayed, Future<V> { } 介面 Sche

java.util.concurrent.RunnableFuture 介面 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public interface RunnableFuture<V> extends Runnable, Future<V> { //在未被取消的情況

java.util.concurrent.TimeUnit

TimeUnit提供了可讀性更好的執行緒暫停操作，通常用來替換Thread.sleep()， 在很長一段時間裡Thread的sleep()方法作為暫停執行緒的標準方式，幾乎所有Java程式設計師都熟悉

java.util.Concurrent.Exchanger 原始碼

類圖       Exchanger 是一個用於執行緒間協作的工具類，Exchanger用於進行執行緒間的資料交換，它提供一個同步點，在這個同步點，兩個執行緒可以交換彼此的資料。這兩個執行緒通過exchange 方法交換資料，如果

java.util.Concurrent.Executors 原始碼

類圖 原始碼： package java.util.concurrent; import java.util.*; import java.util.concurrent.atomic.AtomicInteger; import java.security.Acc

java.util.Concurrent.Semaphore 原始碼

類圖 原始碼： package java.util.concurrent; import java.util.Collection; import java.util.concurrent.locks.AbstractQueuedSynchronizer; publ

java.util.concurrent.AbstractExecutorService 原始碼

執行緒池相關 原始碼： package java.util.concurrent; import java.security.AccessControlContext; import java.security.AccessController; import j

java.util.concurrent.ThreadPoolExecutor 原始碼

執行緒池相關 原始碼： package java.util.concurrent; import java.security.AccessControlContext; import java.security.AccessController; import j

java.util.concurrent.ExecutorCompletionService 原始碼

執行緒池相關 原始碼： package java.util.concurrent; public class ExecutorCompletionService<V> implements CompletionService<V> {

java.util.concurrent.FutureTask 原始碼

執行緒池相關 原始碼： package java.util.concurrent; import java.util.concurrent.locks.LockSupport; public class FutureTask<V> implement

java.util.concurrent.ScheduledThreadPoolExecutor 原始碼

執行緒池相關 原始碼： package java.util.concurrent; import java.util.AbstractQueue; import java.util.Arrays; import java.util.Collection; imp

圖解java.util.concurrent原始碼（三） Reentrantlock && Semaphore

引言 Reentrantlock和Semaphore分別是AQS在獨佔模式和共享模式下經典的實現，在理解AQS的情況下看這兩個類的程式碼會感到非常簡單，如果還沒理解AQS的話，建議先讀我這個系列的第一篇文章 複習AQS 回憶一下AQS，AQS中維護了一個st

Java 併發工具包-java.util.concurrent-原始碼jdk1.7全面解析

先來看看類圖： 其實從類圖我們能發現concurrent包（除去java.util.concurrent.atomic 和 java.util.concurrent.locks）中的內容並沒有特別多，大概分為四類：BlockingQueue阻塞佇列體系、Executor