TimeUnit的简略介绍

偏执的太偏执、 2022-06-04 01:56 296阅读 0赞

**TimeUnit源码参见rt.jar:java.util.concurrent.TimeUnit**

package java.util.concurrent;
    public enum TimeUnit {
        /** Time unit representing one thousandth of a microsecond */
        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)); }
        },
    
        /** Time unit representing one thousandth of a millisecond */
        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)); }
        },
    
        /** Time unit representing one thousandth of a second */
        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; }
        },
    
        /** Time unit representing one second */
        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; }
        },
    
        /** Time unit representing sixty seconds */
        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; }
        },
    
        /** Time unit representing sixty minutes */
        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; }
        },
    
        /** Time unit representing twenty four hours */
        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; }
        };
    
        // 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;
    
        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 表示给定单元粒度的时间段，它提供在这些单元中进行跨单元转换和执行计时及延迟操作的实用工具方法。

TimeUnit 不维护时间信息，但是有助于组织和使用可能跨各种上下文单独维护的时间表示形式。  
TimeUnit 主要用于通知基于时间的方法如何解释给定的计时参数。

部分使用可以参见**rt.jar:java.util.concurrent.locks****.ReentrantLock**

例如，如果 lock 不可用，则以下代码将在 50 毫秒后超时：  
  Lock lock = ...;  
  if ( lock.tryLock(50L, TimeUnit.MILLISECONDS) ) ...  
 而以下代码将在 50 秒后超时：  
  Lock lock = ...;  
  if ( lock.tryLock(50L, TimeUnit.SECONDS) ) ...  
但是注意，不保证特定超时实现能够以与给定 TimeUnit 相同的粒度通知 段。  
枚举常量摘要  
MICROSECONDS    微秒   一百万分之一秒（就是毫秒/1000）  
MILLISECONDS    毫秒   千分之一秒      
NANOSECONDS   毫微秒  十亿分之一秒（就是微秒/1000）  
SECONDS          秒  
MINUTES     分钟  
HOURS      小时  
DAYS      天  
主要接口：  
 long  convert(long duration, TimeUnit unit) 将给定单元的时间段转换到此单元。  
 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  toMicros(long duration) 等效于 MICROSECONDS.convert(duration, this)。  
 long  toMillis(long duration) 等效于 MILLISECONDS.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() 按照声明该枚举类型的常量的顺序，返回包含这些常量的数组。  
注意1：它的常量MICROSECONDS，MILLISECONDS，NANOSECONDS，SECONDS都是TimeUnit类型  
注意2：convert(long duration, TimeUnit unit)的意思将duration这个时间转化为本对象（this）所表示的时间形式。  
本对象可能MICROSECONDS，MILLISECONDS，NANOSECONDS，SECONDS的一种。  
至于duration是哪种形式的时间（MICROSECONDS，MILLISECONDS，NANOSECONDS，SECONDS的一种）， 则是通过参数TimeUnit unit来确定的  
注意3：TimeUnit是enum（枚举）类型，不能通过外部来实例化。  
对用户来说只有它内部定义的下常量可用：MICROSECONDS，MILLISECONDS，NANOSECONDS，SECONDS，MINUTES，HOURS，DAYS  
注意4：对于常量MINUTES，HOURS，DAYS，在Java1.5和Android中并没看到，但是在Java1.6中却有。  
注意5:关于枚举类型的知识可参加《**[枚举类型][Link 1]**》

下面一个小demo列出其中的转换<convert>情况

public class AppTest  extends TestCase {
    	public static void main(String[] args) {
    		long nanoTime = System.nanoTime();
    		System.out.println("nanoTime原身:"+nanoTime);
    		System.out.println("NANOSECONDS转MICROSECONDS:"+TimeUnit.MICROSECONDS.convert(nanoTime,TimeUnit.NANOSECONDS));
    		System.out.println("MILLISECONDS转MICROSECONDS:"+TimeUnit.MICROSECONDS.convert(nanoTime, TimeUnit.MILLISECONDS));
    		System.out.println("NANOSECONDS转MILLISECONDS:"+TimeUnit.MILLISECONDS.convert(nanoTime,TimeUnit.NANOSECONDS));
    		System.out.println("MILLISECONDS转NANOSECONDS:"+TimeUnit.NANOSECONDS.convert(nanoTime, TimeUnit.MILLISECONDS));
    	}
    }
    nanoTime原身:187408555452023
    NANOSECONDS转MICROSECONDS:187408555452
    MILLISECONDS转MICROSECONDS:187408555452023000
    NANOSECONDS转MILLISECONDS:187408555
    MILLISECONDS转NANOSECONDS:9223372036854775807

[Link 1]: http://hubingforever.blog.163.com/blog/static/17104057920107345213394/