测试代码执行时间java,js测试代码运行时间

java代码运行10次的时间

此方法为 Java 内置的方法，使用 System.currentTimeMillis 来执行统计的时间（统计单位：毫秒）（统计单位：毫秒），示例代码如下：

public class TimeIntervalTest {

public static void main(String[] args) throws InterruptedException {

// 开始时间

long stime = System.currentTimeMillis();

// 执行时间（1s）

Thread.sleep(1000);

// 结束时间

long etime = System.currentTimeMillis();

// 计算执行时间

System.out.printf("执行时长：%d 毫秒.", (etime - stime));

}

}

以上程序的执行结果为：

执行时长：1000 毫秒.

方法二：System.nanoTime

此方法为 Java 内置的方法，使用 System.nanoTime 来统计执行时间（统计单位：纳秒），它的执行方法

相关问答

Q1: 如何准确的测试一段java代码的执行时间

检测一个JAVA程序的运行时间方法： long startTime = System.currentTimeMillis();//获取当前时间//doSomeThing(); //要运行的java程序long endTime = System.currentTimeMillis();System.out.println("程序运行时间："+(endTime-startTime)+"ms");

Q2: 计算Java程序执行时间的几种方法

最简单的就是直接获取开始时间、结束时间，计算时间差

public class Demo {

    public static void main(String[] args) {

        long startTime = System.currentTimeMillis();    //获取开始时间

        doSomething();    //测试的代码段

        long endTime = System.currentTimeMillis();    //获取结束时间

        System.out.println("程序运行时间：" + (endTime - startTime) + "ms");    //输出程序运行时间

    }

}

Q3: 有哪位Java大神知怎样测量一个多线程环境的方法的执行时间吗？不要说我神经，这是有迫切需求的，不信请看

将每个 Thread 新建之后赋值给一个引用，如 Thread t = new Thread(......)；

然后调用 t.join(); 这个方法会等待当前线程执行完。就是下面这样：

long t1 = System.currentTimeMillis();

Thread[] threads = new Thread[20];

for (int i = 0; i  20; i++) {

threads[i] = new Thread(new Runnable() {

public void run() {

try {

System.out.println(Version[Low/High]Effective.getInstance());

} catch (Exception e) {

e.printStackTrace();

}

}

});

threads[i].start();

}

for (int i = 0; i  20; i++) {

threads[i].join();

}

long t2 = System.currentTimeMillis();

System.out.println("耗时：" + (t2 - t1) + "毫秒");

至于双重检查为什么要加 volatile，是因为 volatile 关键字在 JDK5 之后，保证了被其修饰的变量的可见性（JDK5 之前的版本是不可以的）。Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比（如果与原始变量不一致则修改原始变量）。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。而volatile赋予了变量可见性——禁止编译器对成员变量进行优化，它修饰的成员变量在每次被线程访问时，都强迫从内存中重读该成员变量的值；而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存，这样在任何时刻两个不同线程总是看到某一成员变量的同一个值，这就是保证了可见性。

所以，假设你的 private static volatile VersionHighEffective  me=null; 没有 volatile 关键字（那么就是 private static VersionHighEffective  me=null;），假设线程 t1 已经 new 了一个 VersionHighEffective 实例，但是这个实例目前可能只是保存在 t1 的“范围”里，还没有被写到主存；此时线程 t2 去执行这段代码：

if(me==null){

     synchronized (VersionHighEffective.class) {

       if (me == null) {

         Thread.sleep(500);

         me = new VersionHighEffective();

       }

     }

   }

很明显 t2 从主存那访问到的 me 仍然是 null，所以最后 t2 又去 new 了一个 VersionHighEffective，这样就不是单例了。所以，加上 volatile 修饰，每次的修改后的变量都会强迫立即写到主存，那么前面的问题就不存在了。