如Java博客文章Beware of System.nanoTime()中所述,在x86系统上,Java的System.nanoTime()使用CPU特定计数器返回时间值.现在考虑以下用于测量呼叫时间的情况:
long time1= System.nanoTime();
foo();
long time2 = System.nanoTime();
long timeSpent = time2-time1;
现在在多核系统中,可能是在测量time1之后,线程被调度到不同的处理器,其计数器小于先前CPU的计数器.因此,我们可以得到time2中的值,该值小于 time1.因此,我们将在timeSpent中得到负值.
考虑到这种情况,是不是System.nanotime现在几乎没用？
我知道改变系统时间不会影响纳米时间.这不是我上面描述的问题.问题是每个CPU都会在打开后保留不同的计数器.与第一个CPU相比,第二个CPU上的计数器可以更低.由于在获取time1之后OS可以将线程调度到第二个CPU,因此timeSpent的值可能不正确甚至是负数.
什么是分析Scala方法调用的标准方法？
我需要的是一个方法的钩子,我可以使用它来启动和停止计时器.
在Java中,我使用方面编程aspectJ来定义要分析的方法并注入字节码以实现相同的目的.
在Scala中是否有更自然的方式,我可以在函数前后定义一组函数,而不会在进程中丢失任何静态类型？
我在配备2.7 GHz Intel Core i7的笔记本电脑上运行以下Java代码.我打算让它测量完成2 ^ 32次迭代循环所需的时间,我预计大约需要1.48秒(4/2.7 = 1.48).
但实际上它只需要2毫秒,而不是1.48秒.我想知道这是否是下面任何JVM优化的结果？
public static void main(String[] args)
{
long start = System.nanoTime();
for (int i = Integer.MIN_VALUE; i < Integer.MAX_VALUE; i++){
}
long finish = System.nanoTime();
long d = (finish - start) / 1000000;
System.out.println("Used " + d);
}
我在互联网上看到我应该使用System.nanoTime(),但这对我不起作用 - 它给了我毫秒精度的时间.我只需要在我的函数执行之前和之后的微秒,这样我就知道需要多长时间.我正在使用Windows XP.
基本上,我有这样的代码,例如,在java链表中进行了100万到1000万次插入.问题是我无法衡量精确度; 有时在较小的列表中插入所有内容所需的时间较少.
这是一个例子:
class test
{
public static void main(String args[])
{
for(int k=1000000; k<=10000000; k+=1000000)
{
System.out.println(k);
LinkedList<Integer> aux = new LinkedList<Integer>();
//need something here to see the start time
for(int i=0; i<k; i++)
aux.addFirst(10000);
//need something here to see the end time
//print here the difference between both times
}
}
}
我这样做了很多次 - 每个k都有一个外部循环做20次 - 但结果并不好.有时需要更少的时间来进行1000万次插入而不是100万次插入,因为我没有使用我现在使用的内容获得正确的测量时间(System.nanoTime())
编辑2:是的,我正在使用Sun JVM.
编辑3:我可能在代码中做错了什么,我会看看改变它是否符合我的要求.
编辑4:我的错误,似乎System.nanoTime()工作.唷.
正如我在启动Java应用程序之前所知道的那样,它为它分配了一些RAM,并且这个内存可以在启动之前由用户控制.但是当我启动应用程序时,每次都有不同的执行时间,还有另一个问题.
这是一个非常简单的for循环示例:
package timespent;
public class Main {
public static void main(String[] args) {
long startTime = System.nanoTime();
int j = 0;
for (int i = 0; i < 1.E6; i++) {
j = i + 1;
}
long endTime = System.nanoTime();
long duration = (endTime - startTime);
System.out.println("duration = " + duration);
}
}
它打印出不同的结果:
duration = 5720542
duration = 7331307
duration = 7737946
duration = 6899173
假设我希望它能够精确地执行10,000,000纳秒或10毫秒.
我希望java应用程序执行精确的时间执行.
当我启动一个应用程序时,我想在加载所有组件之前显示应用程序启动窗口上剩下的确切执行时间.
我想这是一种CPU操作,我想知道它是否可能.
Q1:在Java中有可能吗？
Q2:如果在Java中不可能,那么有没有办法通过访问OS本机方法来实现这一点.例如,通过优先考虑Java应用程序或其他东西？
问题3:如何将应用程序的状态保存到文件并将其加载到内存中？
我在OpenGL中平滑滚动有问题(在SGS2和ACE上测试)
我创建了简单的应用程序 - 只有固定速度的水平滚动图像,或者只有一个图像(播放器)通过加速器移动,但它的运动不顺畅:-(
我试过了许多代码但不满意......
首先我尝试使用GLSurfaceView.RENDERMODE_CONTINUOUSLY并将所有代码放到onDrawFrame:
public void onDrawFrame(GL10 gl)
{
updateGame(gl, 0.017f);
drawGame(gl);
}
这是最简单,最绝对的顺畅! - 但它取决于硬件速度(=无用)
public void onDrawFrame(GL10 gl)
{
frameTime = SystemClock.elapsedRealtime();
elapsedTime = (frameTime - lastTime) / 1000;
updateGame(gl, elapsedTime);
drawGame(gl);
lastTime = frameTime;
}
这是最好的,但它不像以前那样流畅,有时轻弹
我试过GLSurfaceView.RENDERMODE_WHEN_DIRTY,在onDrawFrame我只有绘图对象和这个代码在单独的线程中:
while (true)
{
updateGame(renderer, 0.017f);
mGLSurfaceView.requestRender();
next_game_tick += SKIP_TICKS;
sleep_time = next_game_tick - System.currentTimeMillis();
if (sleep_time >= 0)
{
try
{
Thread.sleep(sleep_time);
}
catch (Exception e) {}
}
else
{
Log.d("running behind: ", String.valueOf(sleep_time)); …给定正整数x和排序正整数数组A
有没有比O(N)确定任何元素A是否是倍数更快的算法x？没有负面因素A.
A到目前为止,Naive循环是我唯一的想法,我不知道是否有任何方法可以利用A为加快速度而排序的事实.
我们有一个Java应用程序需要在虚拟(Hyper-V)Windows 2012 R2 Server上运行,以及其他环境.在此虚拟Windows服务器上执行时,似乎遇到了奇怪的计时问题.我们已经将问题跟踪到Java预定执行程序中的不稳定调度:
public static class TimeRunnable implements Runnable {
private long lastRunAt;
@Override
public void run() {
long now = System.nanoTime();
System.out.println(TimeUnit.NANOSECONDS.toMillis(now - lastRunAt));
lastRunAt = now;
}
}
public static void main(String[] args) {
ScheduledExecutorService exec = Executors.newScheduledThreadPool(1);
exec.scheduleAtFixedRate(new TimeRunnable(), 0, 10, TimeUnit.MILLISECONDS);
}
此代码应每10ms运行一次TimeRunnable,在服务器上生成如下结果:
12
15
2
12
15
0
14
16
2
12
140
0
0
0
0
0
0
0
0
0
0
0
0
1
0
7
15
0
14
16
2
12 …我使用以下代码来测试try块的速度有多慢.令我惊讶的是,try块使它更快.为什么？
public class Test {
int value;
public int getValue() {
return value;
}
public void reset() {
value = 0;
}
// Calculates without exception
public void method1(int i) {
value = ((value + i) / i) << 1;
// Will never be true
if ((i & 0xFFFFFFF) == 1000000000) {
System.out.println("You'll never see this!");
}
}
public static void main(String[] args) {
int i;
long l;
Test t = new Test();
l = System.currentTimeMillis();
t.reset();
for (i = …我检查了下面的页面,没有方法可以获得2009年Java中微秒精度的当前时间.
当前时间以微秒为单位的java
最好的是System.currentTimeMillis(),它以毫秒为单位给出当前时间的准确度,而System.nanoTime()给出当前时间戳的准确度,以纳秒为单位,但是这个时间戳不能用于高精度地转换为当前时间.
我可以在6年后知道Java中是否有任何新的更新？谢谢.
编辑1. System.nanoTime()对于估计持续时间非常有用,但不能提供当前时间.
编辑2.在Java 8中使用解决方案是件好事.在Java 7中还有其他方法吗？谢谢!