TimeUnit的简略介绍

最新推荐文章于 2023-02-17 16:23:51 发布
最新推荐文章于 2023-02-17 16:23:51 发布
阅读量3.1k 收藏 3
点赞数 1
CC 4.0 BY-SA版权
分类专栏： JAVA 文章标签： TimeUnit
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.youkuaiyun.com/u011271894/article/details/78685223

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:关于枚举类型的知识可参加《枚举类型》

下面一个小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


在Java中将时间单位转换为持续时间
最佳 Java 编程
06-15 1293
java.util.concurrent.TimeUnit以给定的粒度单位表示Java中的持续时间，并提供了跨单位转换的实用方法。 java.util.concurrent.TimeUnit最早是在Java早期（1.5）引入的，但自那时以来已经被扩展了好几次。 在此博客文章中，您将学习如何使用java.util.concurrent.TimeUnit将给定的时间单位转换为持续时间 。 先决...
你要的SpringCloud简略指南来了！（Netflix版本）
可乐的博客
07-11 5993
SpringCloud笔记 一、概述 官网简介地址https://spring.io/cloud 1、基于分布式的微服务架构 2、SpringCloud简介 1.What is SpringCloud SpringCloud=分布式微服务架构的一站式解决方案，是多种微服务架构落地技术的集合体，俗称微服务全家桶 2.集成的相关项目 SpringCloud已经成为国际微服务开发的主流技术栈，国内开发者社区十分火爆，同时Alibaba已经加入SpringCloud Alibaba 3.京东架构 4.学习的
TimeUnit 使用
weixin_34413103的博客
05-12 161
TimeUnit是java.util.concurrent包下面的一个类，表示给定单元粒度的时间段 主要作用 时间颗粒度转换 延时   常用的颗粒度 TimeUnit.DAYS //天 TimeUnit.HOURS //小时 TimeUnit.MINUTES //分钟 TimeUnit.SECONDS ...
Java时间转换（TimeUnit和Duration）
PepDokHa的博客
02-17 1775
Java时间转换，TimeUnit，Duration
TimeUnit的使用
每天进步一点点儿
07-18 8094
TimeUnit是java.util.concurrent包下面的一个枚举类，表示给定单元粒度的时间段 主要作用 时间颗粒度转换 延迟执行 常用的颗粒度 NANOSECONDS MICROSECONDS MILLISECONDS SECONDS MINUTES HOURS DAYS 1、时间颗粒度转换 2、延时执行（和Thread.sleep类似...
c#的程序执行时间计算类
weixin_30405421的博客
02-20 147
public class TimerHelper { Stopwatch sw; TimeUnit _timeUnit; public TimerHelper() { _timeUnit = TimeUnit.Millisecond; sw = ...
思维导图04----Java多线程基础
chenyao的博客~
07-05 781
Java多线程基础----思维导图 下载地址: https://download.youkuaiyun.com/download/q863672107/20016412 以下是自动转换的MakeDown文本 多线程 单核CPU执行任务时, 单线程的执行速度比多线程(线程切换)更快 一个Java进程至少有三个线程: main, GC, 异常处理 多线程的优点: 1.提高应用程序的响应。对图形化界面更有意义, 可增强用户体验(同时执行多个任务)。 2.提高计算机系统CPU的利用率, 减少CPU空闲。 3.改善程序结
数据结构与算法的深入应用-限流算法
不积跬步无以至千里。
01-17 453
基于Java实现常见限流算法
java 多线程参数
03-10
在思考过程中，可能会遗漏某些参数，比如线程组（ThreadGroup），不过这个在现代Java中使用较少，可能可以简略提及。另外，线程工厂（ThreadFactory）在创建线程时用于定制线程属性，这也是一个相关点。线程池的工作...
soul源码分析数据同步篇之HTTP长轮询同步流程
evasnowind的专栏
02-08 453
说明 本文代码基于soul 2021.2.4 master分支版本。 准备 请先阅读soul官方文档 数据同步原理，对soul数据同步原理有个基本的了解。 如何开启HTTP同步策略 这个小节主要引自soul官网 使用不同的数据同步策略 soul-admin的配置 application.yml中添加如下配置，或是在启动参数中添加--soul.sync.http=''，然后重启服务： soul: sync: http: enabled: true soul-bootstrap的
TimeUnit使用
weixin_33743661的博客
10-13 233
2019独角兽企业重金招聘Python工程师标准>>> ...
TimeUnit类源码详解（concurrent包下的时间工具类）
dgh112233的博客
06-01 878
目录 1、TimeUnit介绍与基本使用 2、其它的操作方法 2.1、timedWait方法 2.2、timedJoin方法 2.3、sleep方法 2.4、int excessNanos(long d, long m) 方法 1、TimeUnit介绍与基本使用 TimeUnit类的作用：用于时间的换算，比如纳秒，微秒，毫秒，秒，分钟，小时，天等等的换算。 下面看看TimeUnit的源码，提供了每个时间单位的换算方法。 public enum TimeUnit { // .
TimeUnit 的源码解析和API介绍
HuangJiaxinZ的博客
09-20 275
TimeUnit源码解析
TimeUnit 深入源码解析
键盘上流淌的日子
06-27 8369
  TimeUnit是JUC包下提供的一个枚举类，表示给定单元粒度的时间段。   演示示例：   首先，我们先看一个示例，示例中包含了TimeUnit的所有功能。 package com.securitit.serialize.juc; import java.util.Date; import java.util.concurrent.TimeUnit; import org.assertj.core.util.DateUtil; public class TimeUnitTester { pu
TimeUnit源码走读及基本使用
Y
08-24 554
1 背景介绍 笔者遇到一个场景，用户输入到时间和数据库里面时间做对比，由于数据库里面是timestamp类型，（如 2021-08-23 08:28:41），而用户输入一般为小时，分钟，或者毫秒。代码规约规定不能使用java.sql.Time, java.sql.Date, 和java.sql.timestamp, 因为jdk8这3个类有缺陷。 现在假设用户输入是毫秒 (long startTime = System.currentTimeMillis() )，我需要把这个毫秒转变为数据库里面是timest
TimeUnit用法
m0_37846887的博客
05-22 293
参考地址：https://blog.youkuaiyun.com/qq_22230935/article/details/52766354点击打开链接
java timeunit_分享阅读枚举类java.util.concurrent.TimeUnit源码后对定义枚举类有新的认识了解...
weixin_39623805的博客
03-07 146
、一、前言之前定义枚举类enum,基于形式基于枚举类的定义构成函数，枚举项本身根据枚举类定义的属性进行实例化，如下所示，通过阅读java.util.concurrent.TimeUnit,可以基于公共的静态属性，对每一个枚举项基于公共静态属性重新各自的方法，具体参考源码说明部分。publicenumTimeUnit{@b@@b@sec(60,"秒"),@b@min(60,"分"),@b@ho...
Java: LocalDate、LocalDateTime、Duration、Period、TimeUnit类的一些用法
東辰的博客
03-13 1653
一、LocalDate 初始化操作 // 获取当前年月日 LocalDate now = LocalDate.now(); System.out.println(now); // 2021-03-13 // 指定年、月、日创建日期 LocalDate d = LocalDate.of(2077, 1, 1); System.out.println(d); // 2077-01-01 // 通过字符串形式创建 LocalDate d1 = LocalDate.parse("2077-10-01"); Sy
TimeUnit使用和解析
shi2huang的博客
05-12 5636
https://blog.youkuaiyun.com/yuanyl/article/details/45098331http://www.bianceng.cn/Programming/Java/201312/38938.htm
TimeUnit 毫秒
最新发布
07-05
<think>好的，用户现在问的是“TimeUnit 毫秒”，需要给出关于如何在Java中使用TimeUnit来处理毫秒的详细回答。首先，我得回顾一下之前的对话历史，看看有没有相关的信息已经被提到过。之前用户问过关于Java线程睡眠的方式，包括TimeUnit.SECONDS.sleep(1)的使用，所以这次可能需要更具体地聚焦在毫秒级别的操作上。 用户可能想知道如何用TimeUnit来实现毫秒级的休眠，以及相关的注意事项。需要解释TimeUnit.MILLISECONDS.sleep()的用法，并对比Thread.sleep()的差异。同时，可能还需要提到异常处理、中断响应，以及实际应用场景。 接下来，我需要确保回答的结构清晰，包括示例代码、关键特性、常见错误和相关问题。要注意用户可能的疑问点，比如为什么使用TimeUnit而不是直接用Thread.sleep，或者如何处理中断异常。 另外，用户可能希望了解TimeUnit在毫秒级别下的精度和实际应用中的注意事项，比如系统时钟的影响。还要检查是否有遗漏的重要信息，比如TimeUnit的其他方法或者与线程池结合使用的例子。 最后，确保生成的相关问题覆盖TimeUnit的底层实现、异常处理、替代方案、精确性和性能优化等方面，帮助用户深入理解。</think>`TimeUnit.MILLISECONDS.sleep()` 是 Java 中基于 `TimeUnit` 枚举实现的毫秒级线程休眠方法，其本质是对 `Thread.sleep()` 的封装，但通过时间单位枚举提升了代码可读性。以下是详细说明： --- ### **1. 基本用法** ```java try { // 线程休眠 500 毫秒 TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { // 处理中断异常（建议恢复中断状态） Thread.currentThread().interrupt(); } ``` --- ### **2. 与 `Thread.sleep()` 的关系** - **底层实现**：`TimeUnit.MILLISECONDS.sleep(500)` 最终调用的是 `Thread.sleep(500)`。 - **优势**： - **避免硬编码**：直接使用 `MILLISECONDS` 枚举值，无需手动转换（如 `500毫秒 = 0.5秒`）。 - **可读性更高**：明确表达时间单位，减少 `Thread.sleep(500)` 中隐含的毫秒假设。 - **灵活性**：通过枚举切换时间单位（如 `SECONDS`、`MINUTES`）时无需修改数值。 --- ### **3. 关键特性** | 特性 | 说明 | |---------------------|----------------------------------------------------------------------| | **不释放锁** | 休眠期间线程不会释放已持有的锁资源（与 `Object.wait()` 不同）。 | | **中断响应** | 若线程被中断（如调用 `interrupt()`），会抛出 `InterruptedException`。 | | **系统依赖** | 实际精度受操作系统调度器影响（Windows 通常为 15ms，Linux 为 1ms）。 | --- ### **4. 典型应用场景** 1. **高精度延迟控制** 在需要精确到毫秒的场景（如游戏循环、传感器数据采集）中使用： ```java while (true) { readSensorData(); TimeUnit.MILLISECONDS.sleep(10); // 每10毫秒采集一次数据 } ``` 2. **限流与重试策略** 在网络请求失败后实现毫秒级退避重试： ```java for (int i = 0; i < MAX_RETRIES; i++) { if (sendRequest()) break; TimeUnit.MILLISECONDS.sleep((long) Math.pow(2, i) * 100); // 指数退避 } ``` 3. **定时任务调度** 配合 `ScheduledExecutorService` 实现周期性执行： ```java ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); executor.scheduleAtFixedRate(() -> { System.out.println("每200毫秒执行一次"); }, 0, 200, TimeUnit.MILLISECONDS); ``` --- ### **5. 常见错误与修复** - **错误1：忽略中断异常处理** ```java // 错误写法：直接吞掉异常 catch (InterruptedException e) { // 忽略异常 } ``` **修复**：恢复中断状态或向上抛出异常： ```java catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复中断状态 throw new RuntimeException("休眠被中断", e); } ``` - **错误2：过度依赖毫秒精度** **问题**：在 Windows 系统中，`Thread.sleep(1)` 可能实际休眠 15ms。 **解决方案**：使用 `LockSupport.parkNanos(1_000_000)` 实现纳秒级控制（需谨慎使用）。 --- ### **6. 性能考量** - **短时休眠的开销**：频繁调用 `sleep(1)` 可能导致线程频繁挂起和唤醒，影响性能。 - **替代方案**：对于超短时休眠（如等待硬件响应），可考虑自旋锁或 `Busy Wait`（需结合 `Thread.onSpinWait()` 优化）。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一屁小肥咩

您的鼓励将是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值