TimeUnit是java.util.concurrent包下面的一个类,表示给定单元粒度的时间段

1、主要作用

时间颗粒度转换

延时

2、常用的颗粒度

    1. TimeUnit.DAYS //天
      1. TimeUnit.HOURS //小时
        1. TimeUnit.MINUTES //分钟
          1. TimeUnit.SECONDS //秒
            1. TimeUnit.MILLISECONDS //毫秒
              1. TimeUnit.NANOSECONDS //毫微秒
                1. TimeUnit.MICROSECONDS //微秒
              1.  

              3、时间颗粒度转换

                1. public long toMillis(long d) //转化成毫秒
                  1. public long toSeconds(long d) //转化成秒
                    1. public long toMinutes(long d) //转化成分钟
                      1. public long toHours(long d) //转化成小时
                        1. public long toDays(long d) //转化天
                      1.  

                      实例:

                        1. package com.app;
                            1. import java.util.concurrent.TimeUnit;
                                1. public class Test {
                                    1. public static void main(String[] args) {
                                      1. //1天有24个小时 1代表1天:将1天转化为小时
                                        1. System.out.println( TimeUnit.DAYS.toHours( 1 ) );
                                            1. //结果: 24
                                                  1. //1小时有3600秒
                                                    1. System.out.println( TimeUnit.HOURS.toSeconds( 1 ));
                                                        1. //结果3600
                                                              1. //把3天转化成小时
                                                                1. System.out.println( TimeUnit.HOURS.convert( 3 , TimeUnit.DAYS ) );
                                                                  1. //结果是:72
                                                                      1. }
                                                                        1. }
                                                                      1.  

                                                                      4、延时

                                                                      (1)一般的写法

                                                                        1. package com.app;
                                                                            1. public class Test2 {
                                                                                1. public static void main(String[] args) {
                                                                                    1. new Thread( new Runnable() {
                                                                                        1. @Override
                                                                                          1. public void run() {
                                                                                            1. try {
                                                                                              1. Thread.sleep( 5 * 1000 );
                                                                                                1. System.out.println( "延时完成了");
                                                                                                  1. } catch (InterruptedException e) {
                                                                                                    1. e.printStackTrace();
                                                                                                      1. }
                                                                                                        1. }
                                                                                                          1. }).start(); ;
                                                                                                            1. }
                                                                                                                1. }
                                                                                                              1.  

                                                                                                              (2)TimeUnit 写法

                                                                                                                1. package com.app;
                                                                                                                    1. import java.util.concurrent.TimeUnit;
                                                                                                                        1. public class Test2 {
                                                                                                                            1. public static void main(String[] args) {
                                                                                                                                1. new Thread( new Runnable() {
                                                                                                                                    1. @Override
                                                                                                                                      1. public void run() {
                                                                                                                                        1. try {
                                                                                                                                          1. TimeUnit.SECONDS.sleep( 5 );
                                                                                                                                            1. System.out.println( "延时5秒,完成了");
                                                                                                                                              1. } catch (InterruptedException e) {
                                                                                                                                                1. e.printStackTrace();
                                                                                                                                                  1. }
                                                                                                                                                    1. }
                                                                                                                                                      1. }).start(); ;
                                                                                                                                                        1. }
                                                                                                                                                            1. }
                                                                                                                                                          1.  

                                                                                                                                                          5、常用时间段

                                                                                                                                                            1. /**
                                                                                                                                                              1. * 无固定期限
                                                                                                                                                                1. */
                                                                                                                                                                  1. NONE(0, "无固定期限")
                                                                                                                                                                      1. /**
                                                                                                                                                                        1. * 1秒钟
                                                                                                                                                                          1. */
                                                                                                                                                                            1. ,ONE_SEC(1, "1秒钟")
                                                                                                                                                                                1. /**
                                                                                                                                                                                  1. * 5秒钟
                                                                                                                                                                                    1. */
                                                                                                                                                                                      1. ,FIVE_SEC(5, "5秒钟")
                                                                                                                                                                                          1. /**
                                                                                                                                                                                            1. * 10秒钟
                                                                                                                                                                                              1. */
                                                                                                                                                                                                1. ,TEN_SEC(10, "10秒钟")
                                                                                                                                                                                                    1. /**
                                                                                                                                                                                                      1. * 30秒钟
                                                                                                                                                                                                        1. */
                                                                                                                                                                                                          1. ,HALF_A_MIN(30, "30秒钟")
                                                                                                                                                                                                              1. /**
                                                                                                                                                                                                                1. * 1分钟
                                                                                                                                                                                                                  1. */
                                                                                                                                                                                                                    1. ,ONE_MIN(60, "1分钟")
                                                                                                                                                                                                                        1. /**
                                                                                                                                                                                                                          1. * 5分钟
                                                                                                                                                                                                                            1. */
                                                                                                                                                                                                                              1. ,FIVE_MIN(5 * 60, "5分钟")
                                                                                                                                                                                                                                  1. /**
                                                                                                                                                                                                                                    1. * 10分钟
                                                                                                                                                                                                                                      1. */
                                                                                                                                                                                                                                        1. ,TEN_MIN(10 * 60, "10分钟")
                                                                                                                                                                                                                                            1. /**
                                                                                                                                                                                                                                              1. * 20分钟
                                                                                                                                                                                                                                                1. */
                                                                                                                                                                                                                                                  1. ,TWENTY_MIN(20 * 60, "20分钟")
                                                                                                                                                                                                                                                      1. /**
                                                                                                                                                                                                                                                        1. * 30分钟
                                                                                                                                                                                                                                                          1. */
                                                                                                                                                                                                                                                            1. ,HALF_AN_HOUR(30 * 60, "30分钟")
                                                                                                                                                                                                                                                                1. /**
                                                                                                                                                                                                                                                                  1. * 1小时
                                                                                                                                                                                                                                                                    1. */
                                                                                                                                                                                                                                                                      1. ,ONE_HOUR(60 * 60, "1小时")
                                                                                                                                                                                                                                                                          1. /**
                                                                                                                                                                                                                                                                            1. * 1天
                                                                                                                                                                                                                                                                              1. */
                                                                                                                                                                                                                                                                                1. ,ONE_DAY(24 * 60 * 60, "1天")
                                                                                                                                                                                                                                                                                    1. /**
                                                                                                                                                                                                                                                                                      1. * 1个月
                                                                                                                                                                                                                                                                                        1. */
                                                                                                                                                                                                                                                                                          1. ,ONE_MON(30 * 24 * 60 * 60, "1个月")
                                                                                                                                                                                                                                                                                              1. /**
                                                                                                                                                                                                                                                                                                1. * 1年
                                                                                                                                                                                                                                                                                                  1. */
                                                                                                                                                                                                                                                                                                    1. ,ONE_YEAR(365 * 24 * 60 * 60, "1年")
                                                                                                                                                                                                                                                                                                  1.  

                                                                                                                                                                                                                                                                                                  TimeUnit用法的更多相关文章

                                                                                                                                                                                                                                                                                                  1. 多线程java的concurrent用法详解(转载)

                                                                                                                                                                                                                                                                                                    我们都知道,在JDK1.5之前,Java中要进行业务并发时,通常需要有程序员独立完成代码实现,当然也有一些开源的框架提供了这些功能,但是这些依然没有JDK自带的功能使用起来方便.而当针对高质量Java ...

                                                                                                                                                                                                                                                                                                  2. 四种Java线程池用法解析

                                                                                                                                                                                                                                                                                                    本文为大家分析四种Java线程池用法,供大家参考,具体内容如下 http://www.jb51.net/article/81843.htm 1.new Thread的弊端 执行一个异步任务你还只是如下 ...

                                                                                                                                                                                                                                                                                                  3. java的concurrent用法详解

                                                                                                                                                                                                                                                                                                    我们都知道,在JDK1.5之前,Java中要进行业务并发时,通常需要有程序员独立完成代码实现,当然也有一些开源的框架提供了这些功能,但是这些依然没有JDK自带的功能使用起来方便.而当针对高质量Java ...

                                                                                                                                                                                                                                                                                                  4. java5 Lock用法

                                                                                                                                                                                                                                                                                                    锁是控制多个线程对共享资源进行访问的工具.通常,锁提供了对共享资源的独占访问.一次只能有一个线程获得锁,对共享资源的所有访问都需要首先获得锁.不过,某些锁可能允许对共享资源并发访问,如 ReadWri ...

                                                                                                                                                                                                                                                                                                  5. CountDownLatch和CyclicBarrier区别及用法的demo

                                                                                                                                                                                                                                                                                                    javadoc里面的描述是这样的. CountDownLatch: A synchronization aid that allows one or more threads to wait unti ...

                                                                                                                                                                                                                                                                                                  6. synchronized Lock用法

                                                                                                                                                                                                                                                                                                    在介绍Lock与synchronized时,先介绍下Lock: public interface Lock { void lock(); void lockInterruptibly() throws ...

                                                                                                                                                                                                                                                                                                  7. Java线程池ThreadPoolExecutor原理和用法

                                                                                                                                                                                                                                                                                                    1.ThreadPoolExecutor构造方法 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAli ...

                                                                                                                                                                                                                                                                                                  8. java多线程管理 concurrent包用法详解

                                                                                                                                                                                                                                                                                                        我们都知道,在JDK1.5之前,Java中要进行业务并发时,通常需要有程序员独立完成代码实现,当然也有一些开源的框架提供了这些功能,但是这些依然没有JDK自带的功能使用起来方便.而当针对高质量 ...

                                                                                                                                                                                                                                                                                                  9. CountDownLatch/CyclicBarrie用法记录

                                                                                                                                                                                                                                                                                                    在jdk1.5中,java提供了很多工具类帮助我们进行并发编程,其中就有CountDownLatch和CyclicBarrie 1.CountDownLatch的用法 CountDownLatch 位 ...

                                                                                                                                                                                                                                                                                                  随机推荐

                                                                                                                                                                                                                                                                                                  1. Apple Watch 集成环信SDK

                                                                                                                                                                                                                                                                                                    本文简单的讲述下怎样用Apple Watch Kit集成环信SDK. 升级xcode到version 6.2,和 IOS SDK8.2 下载环信SDK从官网 打开XCode->new proje ...

                                                                                                                                                                                                                                                                                                  2. Netty推荐addListener回调异步执行

                                                                                                                                                                                                                                                                                                    说明 Netty推荐使用addListener的方式来回调异步执行的结果,这种方式优于Future.get,能够更精确地把握异步执行结束的时间. 错误理解使用addListener的方式 代码如下: ...

                                                                                                                                                                                                                                                                                                  3. [转]Linq使用心得——SelectMany替代二重foreach循环

                                                                                                                                                                                                                                                                                                    本篇记录了Linq学习的心得,较为浅显,各位大牛请轻拍. 学习Linq其实已经很久了,但是一直没有使用的习惯,故水平也始终没有提高.近来刻意强迫自己用Linq来替代C# 2.0的一些写法.这里有一些心 ...

                                                                                                                                                                                                                                                                                                  4. C# mongodb帮助类

                                                                                                                                                                                                                                                                                                    这是在C#连接MongoDB的帮助类,所使用的驱动是在Vs2015的Nuget管理器中下载的mongodb驱动. 下载第一个,会自动下载下面的两个,不要删除. 在配置文件中配置连接字符串connStr ...

                                                                                                                                                                                                                                                                                                  5. POJ 2376 Cleaning Shifts 区间覆盖问题

                                                                                                                                                                                                                                                                                                    http://poj.org/problem?id=2376 题目大意: 给你一些区间的起点和终点,让你用最小的区间覆盖一个大的区间. 思路: 贪心,按区间的起点找满足条件的并且终点尽量大的. 一开始 ...

                                                                                                                                                                                                                                                                                                  6. Android原生生成JSON与解析JSON

                                                                                                                                                                                                                                                                                                    JSON数据是一种轻量级的数据交换格式,在Android中通常应用于client与server交互之间的传输数据.像如今在网上有非常多解析JSON数据的jar包,可是归根究竟用的都是Android原生 ...

                                                                                                                                                                                                                                                                                                  7. Dynamics CRM 2015/2016 Web API:Unbound Function 和 Bound Function

                                                                                                                                                                                                                                                                                                    今天我们来看看Dynamics CRM Web API Function 吧, 这是一个新概念,刚接触的时候我也是比較的迷糊.这种命名确实是和之前的那套基于SOAP协议的API全然联系不上.好了,不说 ...

                                                                                                                                                                                                                                                                                                  8. SiFive Unleashed启动

                                                                                                                                                                                                                                                                                                    SiFive Unleashed启动 请仔细参看SiFive官网的文档HiFive Unleashed 使用串口连接过程 连接好硬件(电源+USB) 尝试打开电源键,检测硬件能被识别 配置minico ...

                                                                                                                                                                                                                                                                                                  9. js模仿块级作用域(js没有块级作用域私有作用域)

                                                                                                                                                                                                                                                                                                    js模仿块级作用域(js没有块级作用域私有作用域) 一.总结 1.js没有块级作用域:在for循环中定义的i,出了for循环还是有这个i变量 2.js可以模拟块级作用域:用立即执行的匿名函数:(匿名函 ...

                                                                                                                                                                                                                                                                                                  10. 判断客户端是iPad、安卓还是ios

                                                                                                                                                                                                                                                                                                    武穆逸仙 有人心疼时,眼泪才是眼泪,否则只是带着咸味的液体:被人呵护着,撒娇才是撒娇,要不然就是作死. 努力做一个可爱的人,不埋怨谁,不嘲笑谁,也不羡慕谁,阳光下灿烂,风雨中奔跑,做自己的梦,走自己的 ...