精华内容
下载资源
问答
  • System.nanoTime()返回的是纳秒,nanoTime而返回的可能是任意时间,甚至可能是负数。System.currentTimeMillis调用的是native方法,使用的是系统的时间,每个JVM对应的应该是相同的,但因为具体的取值依赖于操作系统...

    System.currentTimeMillis()返回的毫秒,这个毫秒其实就是自1970年1月1日0时起的毫秒数。

    System.nanoTime()返回的是纳秒,nanoTime而返回的可能是任意时间,甚至可能是负数。

    System.currentTimeMillis调用的是native方法,使用的是系统的时间,每个JVM对应的应该是相同的,但因为具体的取值依赖于操作系统的实现,不同JVM间可能会有略微的差异。

    System.nanoTime每个JVM维护一份,和系统时间无关,可用于计算时间间隔,比System.currentTimeMillis的精度要高。

    修改了系统时间会对System.currentTimeMillis造成影响,而对System.nanoTime没有影响。修改系统时间后会有如下效果:Timmer有影响,Thread.sleep有影响,ScheduledThreadPoolExecutor无影响,可以查看方法的实现调用的是System.currentTimeMillis还是System.nanoTime。

    java修改系统时间:

    1.windows环境下:

    Runtime.getRuntime().exec("cmd /c date 2013-05-06");//Windows 系统

    Runtime.getRuntime().exec("cmd /c time 22:35:00");//Windows 系统

    2.linux环境下:

    Runtime.getRuntime().exec(" sudo date -s 2013-05-06")//linux 系统为tomcat用户分配了权限

    Runtime.getRuntime().exec(" sudo date -s 22:25:00")//linux 系统为tomcat用户分配了权限

    Linux上获取的时间不正确,总是相差几小时考虑时差的问题,修改/etc/sysconfig/clock。

    展开全文
  • Java System nanoTime()方法java.lang.System.nanoTime()方法返回最精确的可用系统计时器的当前值,以毫微秒为单位。返回的值表示从一些固定的,任意时间纳秒(在未来,那么值可以是负的),并提供纳秒精度,但不一定...

    Java System nanoTime()方法

    java.lang.System.nanoTime() 方法返回最精确的可用系统计时器的当前值,以毫微秒为单位。返回的值表示从一些固定的,任意时间纳秒(在未来,那么值可以是负的),并提供纳秒精度,但不一定是纳秒级的精度。

    1 语法

    public static long nanoTime()

    2 参数

    3 返回值

    此方法返回系统计时器的当前值,以毫微秒为单位。

    4 示例

    package com.yiidian;

    /**

    * 一点教程网: http://www.yiidian.com

    */

    /**

    * Java System nanoTime()方法

    */

    import java.lang.*;

    public class SystemDemo {

    public static void main(String[] args) {

    // returns the current value of the system timer, in nanoseconds

    System.out.print("time in nanoseconds = ");

    System.out.println(System.nanoTime());

    // returns the current value of the system timer, in milliseconds

    System.out.print("time in milliseconds = ");

    System.out.println(System.currentTimeMillis());

    }

    }

    输出结果为:

    time in nanoseconds = 255073580723571

    time in milliseconds = 1349311227921

    展开全文
  • java nanotime 系统类nanoTime()方法 (System class nanoTime() method) nanoTime() method is available in java.lang package. nanoTime()方法在java.lang包中可用。 nanoTime() method is used to return the ...

    java nanotime

    系统类nanoTime()方法 (System class nanoTime() method)

    • nanoTime() method is available in java.lang package.

      nanoTime()方法在java.lang包中可用。

    • nanoTime() method is used to return the value of the current system time in nanoseconds.

      nanoTime()方法用于返回当前系统时间的值(以纳秒为单位)。

    • nanoTime() method is static, it is accessible with the class name too.

      nanoTime()方法是静态的,也可以使用类名进行访问。

    • nanoTime() method does not throw any exception.

      nanoTime()方法不会引发任何异常。

    Syntax:

    句法:

        public static long nanoTime ();
    
    

    Parameter(s):

    参数:

    • It does not accept any parameter.

      它不接受任何参数。

    Return value:

    返回值:

    The return type of this method is long, it returns the current system time in nanoseconds.

    此方法的返回类型为long ,它以纳秒为单位返回当前系统时间。

    Example:

    例:

    // Java program to demonstrate the example of 
    // nanoTime() method of System Class
    
    public class NanoTime {
        public static void main(String[] args) {
            System.out.print("The current time is: ");
            System.out.println(System.nanoTime() + " ns");
        }
    }
    
    

    Output

    输出量

    E:\Programs>javac NanoTime.java
    E:\Programs>java NanoTime
    The current time is: 4254185681871084 ns
    
    
    

    翻译自: https://www.includehelp.com/java/system-class-nanotime-method-with-example.aspx

    java nanotime

    展开全文
  • 最近在看datax的源码,看到System.nanoTime() ,特地学习记录下; 1,上源码 (System类) System.nanoTime() /** * Returns the current value of the running Java Virtual Machine's * high-resolution time ...

    最近在看datax的源码,看到System.nanoTime() ,特地学习记录下;

    1,上源码 (System类)

    System.nanoTime()

        /**
         * Returns the current value of the running Java Virtual Machine's
         * high-resolution time source, in nanoseconds.
         *
         * <p>This method can only be used to measure elapsed time and is
         * not related to any other notion of system or wall-clock time.
         * The value returned represents nanoseconds since some fixed but
         * arbitrary <i>origin</i> time (perhaps in the future, so values
         * may be negative).  The same origin is used by all invocations of
         * this method in an instance of a Java virtual machine; other
         * virtual machine instances are likely to use a different origin.
         *
         * <p>This method provides nanosecond precision, but not necessarily
         * nanosecond resolution (that is, how frequently the value changes)
         * - no guarantees are made except that the resolution is at least as
         * good as that of {@link #currentTimeMillis()}.
         *
         * <p>Differences in successive calls that span greater than
         * approximately 292 years (2<sup>63</sup> nanoseconds) will not
         * correctly compute elapsed time due to numerical overflow.
         *
         * <p>The values returned by this method become meaningful only when
         * the difference between two such values, obtained within the same
         * instance of a Java virtual machine, is computed.
         *
         * <p> For example, to measure how long some code takes to execute:
         *  <pre> {@code
         * long startTime = System.nanoTime();
         * // ... the code being measured ...
         * long estimatedTime = System.nanoTime() - startTime;}</pre>
         *
         * <p>To compare two nanoTime values
         *  <pre> {@code
         * long t0 = System.nanoTime();
         * ...
         * long t1 = System.nanoTime();}</pre>
         *
         * one should use {@code t1 - t0 < 0}, not {@code t1 < t0},
         * because of the possibility of numerical overflow.
         *
         * @return the current value of the running Java Virtual Machine's
         *         high-resolution time source, in nanoseconds
         * @since 1.5
         */
        public static native long nanoTime();
    
    翻译下来如下:
    
    返回正在运行的Java虚拟机的高分辨率时间源的当前值,以纳秒计。
    
    该方法可能仅仅用于测量已经逝去的时间,并且与任何其它系统或者挂钟时间概念无关。该返回值表示从某个固定但任意的原点时间(可能在未来,所以值可能是负数)开始的纳秒数。在一个java虚拟机实例中,所有该方法的调用都使用相同的原点;其它虚拟机实例很可能使用不同的源头。
    
    该方法提供了纳秒级别的精度,但是不一定是纳秒级分辨率(也就是该值改变的频率)———— 除非这个分辨率至少和currentTimeMillis()一样好,否则将不会做任何保证。
    
    在跨越大于292年(2的63次方纳秒)左右的连续调用中,这个差值将不能正确地计算已经过去的时间,因为数字溢出。
    
    仅仅只有当在同一java虚拟机实例中获取的两个值之间的差值被计算时,返回值才有意义。
    
    例如,去测量某代码执行花费了多长时间:
     long startTime = System.nanoTime();
     //...被测量的代码...
     long estimatedTime = System.nanoTime() - startTime;
    
    要比较两个nanoTime的值:
     long t0 = System.nanoTime();
     ...
     long t1 = System.nanoTime()。
    因为数字溢出的可能性,您应该使用"t1 - t0 < 0",而不是"t1 < t0"(来判断它们的大小,笔者注)。
    @return 当前正在运行的java虚拟机的高精度时间资源值,以纳秒为单位。
    @since 1.5
    

    System.currentTimeMillis()

        /**
         * Returns the current time in milliseconds.  Note that
         * while the unit of time of the return value is a millisecond,
         * the granularity of the value depends on the underlying
         * operating system and may be larger.  For example, many
         * operating systems measure time in units of tens of
         * milliseconds.
         *
         * <p> See the description of the class <code>Date</code> for
         * a discussion of slight discrepancies that may arise between
         * "computer time" and coordinated universal time (UTC).
         *
         * @return  the difference, measured in milliseconds, between
         *          the current time and midnight, January 1, 1970 UTC.
         * @see     java.util.Date
         */
        public static native long currentTimeMillis();
    
    翻译
    *返回当前时间(以毫秒为单位)。请注意,虽然*返回值的时间单位是毫秒,但是*值的粒度
    取决于基础*操作系统,并且可能更大。例如,许多*操作系统以数十*毫秒为单位测量时间。
    
    * <p>有关*“计算机时间”和协调世界时(UTC)之间可能出现的细微差异的讨论,请参见类
    * <code> Date </ code>的描述。
    

    2,解读

    currentTimeMillis()

       (1)从源码中可以看到,这个方式是一个native方法,该值由底层提供。
    
       (2)该方法可以用来计算当前日期,当前星期几等,与Date的换算非常方便,JDK提供了相关的接口来换算。
    
       (3)通过该方法获取的值的依据是当前系统的日期和时间,可以在系统设置中进行设置和修改。
    

    nanoTime()

    (1)该方法也是一个本地方法,返回值由底层提供。
    
    (2)如注释中所说,该方法从java 1.5开始引入。 
    
    (3)该方法所基于的时间是随机的,但在同一个JVM中,不同的地方使用的原点时间是一样的。
    

    3,区别与选择

    (1)System.nanoTime()的精确度更高一些,如今的硬件设备性能越来越好,如果要更精密计算执行某行代码或者某块代码所消耗的时间,该方法会测量得更精确。开发者可以根据需要的精确度来选择用哪一个方法。
    
    (2)单独获取System.nanoTime()没有什么意义,因为该值是随机的,无法表示当前的时间。如果要记录当前时间点,用System.currentTimeMills()。
    
    (3)System.currentTimeMills()得到的值能够和Date类方便地转换,jdk提供了多个接口来实现;但是System.nanoTime()则不行。
    
    (4) System.currentTimeMills()的值是基于系统时间的,可以人为地进行修改;而System.nanoTime()则不能,所以如文章开头笔者碰到的问题一样,如果需要根据时间差来过滤某些频繁的操作,用System.nanoTime()会比较合适。
    
    展开全文
  • 系统类nanoTime()方法nanoTime()方法在java.lang包中可用。nanoTime()方法用于返回当前系统时间的值(以纳秒为单位)。nanoTime()方法是静态的,也可以使用类名进行访问。nanoTime()方法不会引发任何异常。语法:...
  • 另一个是System.nanoTime()返回的是纳秒。“纳”这个单位 一般不是第一次见。前几年相当火爆的“纳米”和他是同一级别。纳表示的是10的-9次方。在真空中,光一纳秒也只能传播30厘米。比纳秒大一级别的是微秒,10的-6...
  • currentTimeMillis与nanoTime

    2019-03-19 13:50:35
    nanoTime:毫微秒级,不可做时间参考,计算程序运行时间更精确 public class MyTest{ public static void main(String[] args){ for(int i=0;i<20;i++){ long start1 = System.nanoTime(); ...
  • 在JDK中,System类中有个nanoTime()的方法,可以获取JVM的机器时间./*** Returns the current value of the running Java Virtual Machine's* high-resolution time source, in nanoseconds.** This method can only ...
  • ns(nanosecond):纳秒,时间单位。一秒的10亿分之一,即...1纳秒=1000皮秒1纳秒 =0.001微秒1纳秒=0.000001毫秒1纳秒=0.00000 0001秒java的System.currentTimeMillis()和System.nanoTime()有什么区别java中System.na...
  • java - System.nanoTime()完全没用吗?如Java博客文章Beware of System.nanoTime()中所述,在x86系统上,Java的System.nanoTime()使用CPU特定计数器返回时间值。 现在考虑以下用于测量呼叫时间的情况:long time1= ...
  • 时间单位换算 1s=10^3ms(毫秒)=10^6μs(微秒)=10^9ns(纳秒)=10^12ps(皮秒)=10^15fs(飞秒)=10^18as(阿...currentTimeMillis与 nanoTime是java.lang.System中提供的提供的两个方法。 1、public static long curren...
  • Java精确测量代码运行时间:long startTime = System.nanoTime(); //開始時間 for(int i = 0;i<10000;i++){ ; } long consumingTime = System.nanoTime() - startTime; //消耗時間 Sys...
  • 转自:http://blog.csdn.net/yuansuruanjian/article/details/8562890JDK1.5之后java中的计时给出了更精确的方法:System.nanoTime(),输出的精度是纳秒级别,这个给一些性能测试提供了更准确的参考。但是这个方法有...
  • System之nanoTime函数

    万次阅读 2018-01-30 09:12:23
    1 System有一个静态的函数nanoTime函数,该函数是返回纳秒的。1毫秒=1纳秒*1000*1000 如:long time1=System.nanoTime(); 2 System的nanoTime函数式返回纳秒,但是该函数只能用于计算时间差,不能用于计算距离...
  • System有一个静态的函数nanoTime函数,该函数是返回纳秒的。1毫秒=1纳秒*1000*1000。 long nano = System.nanoTime(); 该函数只能用于计算时间差。 System.nanoTime与System.currentTimeMillis比较 首先: ...
  • System.nanoTime与System.currentTimeMillis比较首先:currentTimeMillis返回的是系统当前时间和1970-01-01之前间隔时间的毫秒数,如果系统时间固定则方法返回值也是一定的(这么说是为了强调和nanoTime的区别),...
  • runtime.(*gcControllerState).findRunnableGCWorker: relocation target runtime.nanotime not defined runtime.pollFractionalWorkerExit: relocation target runtime.nanotime not defined runtime.gcStart: ...
  • System.nanoTime()的文件说如下(强调我的)。This method can only be used to measure elapsed time and is not related to any other notion of system or wall-clock time. The value returned represents ...
  • 该帖子是错误的,并且nanoTime很安全。Sun的实时与并发专家David Holmes对该博文进行了评论,并链接到该博文。它说:使用QueryPerformanceCounter / QueryPerformanceFrequency API实现System....
  • JDK7和JDK8下的System.nanoTime()输出完全不一样,而且差距还非常大,是不是两个版本里的实现不一样,之前我也没注意过这个细节,觉得非常奇怪,于是自己也在本地mac机器上马上测试了一下,得到如下输出:~/...
  • ns(nanosecond):纳秒,时间单位。一秒的10亿分之一,即...1纳秒=1000皮秒1纳秒 =0.001微秒1纳秒=0.000001毫秒1纳秒=0.00000 0001秒java的System.currentTimeMillis()和System.nanoTime()有什么区别java中System.na...
  • System.nanoTime

    2016-02-15 22:15:00
     System.nanoTime()返回的是纳秒,nanoTime而返回的可能是任意时间,甚至可能是负数。  System.currentTimeMillis调用的是native方法,使用的是系统的时间,每个JVM对应的应该是相同的,但因为具体的取值依赖于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 980
精华内容 392
关键字:

nanotime