我正在使用一些代码来计算计算某些Java代码所需的时间,以了解Java某些功能的效率或低效率.这样做我现在陷入了一些非常奇怪的效果,我无法解释自己.也许你们中的某个人可以帮助我理解它.
public class PerformanceCheck {
public static void main(String[] args) {
List<PerformanceCheck> removeList = new LinkedList<PerformanceCheck>();
int maxTimes = 1000000000;
for (int i=0;i<10;i++) {
long time = System.currentTimeMillis();
for (int times=0;times<maxTimes;times++) {
// PERFORMANCE CHECK BLOCK START
if (removeList.size() > 0) {
testFunc(3);
}
// PERFORMANCE CHECK BLOCK END
}
long timeNow = System.currentTimeMillis();
System.out.println("time: " + (timeNow - time));
}
}
private static boolean testFunc(int test) {
return 5 > test;
}
}
启动这会导致相对较长的计算时间(请记住removeList为空,因此甚至不调用testFunc):
time: 2328
time: 2223
... …在Java中，我有两个不同的语句，它们通过使用三元运算符来完成相同的结果，如下所示：
num < 0 ? 0 : num;num * (num < 0 ? 0 : 1);看起来第二个语句不必要地复杂并且比第一个语句花费的时间更长，但是当我使用以下代码记录每个花费的时间时，结果如下：
final long startTime = System.currentTimeMillis();
Random rand = new Random();
float[] results = new float[100000000];
for (int i = 0; i < 100000000; i++) {
float num = (rand.nextFloat() * 2) - 1;
results[i] = num < 0 ? 0 : num;
//results[i] = num * (num < 0 ? 0 : 1);
}
final long endTime = System.currentTimeMillis();
System.out.println("Total Time: " …如何在文本中添加字幕行为JLabel？
我试过这个
JLabel search = new JLabel("<html><marquee>Search</marquee><html>");
但它不起作用.
我有一个奇怪的问题 - 我希望有人可以向我解释发生了什么,以及可能的解决方法.我在Java中实现了一个Z80核心,并试图通过在一个单独的线程中使用java.util.Timer对象来减慢它的速度.
基本设置是我有一个线程运行一个执行循环,每秒50次.在此执行循环中,执行许多循环,然后调用wait().外部Timer线程将每隔20ms调用Z80对象上的notifyAll(),模拟PAL Sega主系统时钟频率为3.54 MHz(ish).
我上面描述的方法在Windows 7(试过两台机器)上工作得很好,但我也试过两台Windows XP机器,而且在这两台机器上,Timer对象似乎睡过了大约50%左右.这意味着在Windows XP计算机上,一秒钟的仿真时间实际上大约需要1.5秒左右.
我尝试使用Thread.sleep()而不是Timer对象,但这具有完全相同的效果.我意识到大多数操作系统的时间粒度不会超过1毫秒,但我可以忍受999毫秒或1001毫秒而不是1000毫秒.我不能忍受的是1562ms - 我只是不明白为什么我的方法在较新版本的Windows上运行正常,但不是旧版本 - 我调查了中断期等等,但似乎没有已经开发出一种解决方法.
有谁能告诉我这个问题的原因和建议的解决方法？非常感谢.
更新:这是我为了显示相同问题而构建的较小应用的完整代码:
import java.util.Timer;
import java.util.TimerTask;
public class WorkThread extends Thread
{
private Timer timerThread;
private WakeUpTask timerTask;
public WorkThread()
{
timerThread = new Timer();
timerTask = new WakeUpTask(this);
}
public void run()
{
timerThread.schedule(timerTask, 0, 20);
while (true)
{
long startTime = System.nanoTime();
for (int i = 0; i < 50; i++)
{
int a = 1 + 1;
goToSleep();
}
long timeTaken = …这是线程正在等待notify()或超时的情况.这里添加了一个while循环来处理虚假唤醒.
boolean dosleep = true;
while (dosleep){
try {
wait(2000);
/**
* Write some code here so that
* if it is spurious wakeup, go back and sleep.
* or if it is timeout, get out of the loop.
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
}
在这种情况下,我如何区分虚假唤醒和超时？如果它是一个虚假的醒来,我需要回去等待.如果是超时,我需要退出循环.
我可以很容易地识别notify()的情况,因为我将在notify()调用时将dosleep变量设置为false.
编辑:由于嵌入式项目的要求,我使用的是1.4版java.我不能使用,Condition因为它只在1.5后可用.
提前致谢.
我的目标是编写一个框架,用于测量方法执行或事务时间以及处理测量,即存储,分析等.事务可能包括调用外部系统,同步或异步等待结果.
关于这个话题已经存在一些问题,比如
所有的答案归结为三种方法来花时间
System.currentTimeMillis()System.nanoTime()Instant.now()和Duration(自Java 8以来)我知道,所有这些都有一些影响
该方法的结果取决于平台.在Linux上你获得1ms的分辨率,在Windows中你得到10ms(单核)~15ms(多核).因此,可以测量大型运行操作或短期运行操作的多次执行.
你得到一个高分辨率的时间测量,具有纳秒精度(但不一定是纳秒精度),并且在292年之后你会得到溢出(我可以忍受它).
从Java 8开始,就有了新的时间API.瞬间有第二个和第二个纳米字段,因此它在对象引用的顶部使用两个长值(相同Duration).您还可以获得纳秒精度,具体取决于基础时钟(请参阅" 具有纳秒分辨率的Java 8 Instant.now()？ ").实例化是通过调用Instant.now()哪些映射到System.currentTimeMillis()正常的系统时钟来完成的.
鉴于事实,很明显,最佳精确度只能通过实现System.nanoTime(),但我的问题更多地针对处理一般措施的最佳做法,这不仅包括采取措施,还包括措施处理.
Instant和Duration提供最佳API支持(计算,比较等),但在标准情况下具有os-dependend精度,内存和创建度量的更多开销(对象构造,更深的callstack)
System.nanoTime()和System.currentTimeMillis()具有不同的精度级别,但只有基本的"api"支持(数学操作为long),但更快和更小以保持在内存中.
那么最好的方法是什么？有没有我没想过的含义？还有其他选择吗？
我的android程序有以下方法,用Java编写.
该方法接受一个十六进制字符串,并返回以ascii编写的相同文本的字符串.
public static String hexToString(String hex)
{
StringBuilder sb = new StringBuilder();
for (int count = 0; count < hex.length() - 1; count += 2)
{
String output = hex.substring(count, (count + 2)); //grab the hex in pairs
int decimal = Integer.parseInt(output, 16); //convert hex to decimal
sb.append((char)decimal); //convert the decimal to character
}
return sb.toString();
}
该方法工作正常,但我的程序非常关键,这种方法可能被称为成千上万次.在分析程序的慢速位时,由于以下原因,此方法占用了太多时间:
Integer.parseInt(output, 16);
和
hex.substring(count, (count + 2));
以最慢的顺序排在第一位.
有谁知道更快的方法来实现同样的事情？
程序中的紧密循环是不是很糟糕？
我有一个应用程序有两个线程的游戏物理模拟器.updateGame线程和渲染线程.通过使线程休眠几毫秒(以实现我想要的帧速率)来限制渲染线程,并且updateGame线程(基于某些物理方程更新我的游戏对象位置)之前被10毫秒的睡眠限制.
然而,我最近没有对updateGame线程进行了限制,并且我的对象运动的模拟似乎更加逼真,因为我已经取出了10ms的睡眠时间.热循环或紧密循环是不是很糟糕？
private class UpdateTask implements Runnable
{
private long previousTime = System.currentTimeMillis();
private long currentTime = previousTime;
private long elapsedTime;
public void run()
{
while(true)
{
currentTime = System.currentTimeMillis();
elapsedTime = (currentTime - previousTime); // elapsed time in seconds
updateGame(elapsedTime / 1000f);
try {
Thread.currentThread().sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
previousTime = currentTime;
}
}
}
在这个例子中,我只是睡了1ms(根据我对毫秒精度和睡眠功能如何工作的理解,这可能更像是5-10ms.如果我睡不着这个,它开始影响精确度我的碰撞检测和物理模型.
拥有1ms睡眠的紧密循环或循环是一种不好的做法吗？还有什么我应该做的吗？
基于链接中提出的想法,我实现了几种不同的"睡眠方法".其中一种方法是"二进制睡眠",它看起来像这样:
while (System.currentTimeMillis() < nextTimeStamp)
{
sleepTime -= (sleepTime / 2);
sleep(sleepTime);
}
因为检查是否已经到达下一个时间步骤发生在开头I,所以预计该方法运行时间太长.但模拟误差的累积分布(预期时间 - 实时)如下所示:alt text http://img267.imageshack.us/img267/4224/errorvscummulativearran.jpg
有人知道我为什么会得到这个结果吗？也许方法System.currentTimeMillis()没有真正返回当前时间？
BR,
马库斯
@irreputable
当我进行评估时,我还使用德国统计程序创建了钟形曲线.因为无法更改标题,所以这里是所有相关项目的英文翻译:
Häufigkeit=频率
费勒=错误
Mittelwert =平均值
Std-Abw =标准偏差
alt text http://img694.imageshack.us/img694/2254/bellcurve.jpg
我已经实现了(在Java中)Insertion Sort,MergeSort,ModifiedMergeSort和Quick Sort:
ModifiedMergeSort有一个变量用于元素的"绑定".当要排序的元素小于或等于"bound"时,请使用Insertion Sort对它们进行排序.
为什么版本1比版本3,4和5更好？
版本2和6的结果是否真实？
这是我的结果(以毫秒为单位):
Version 1 - Insertion Sort: Run-Times over 50 test runs
Input Size Best-Case Worst-Case Average-Case
N = 10000 14 19 14.96
N = 20000 59 60 59.3
N = 40000 234 277 243.1
Version 2 - Merge Sort: Run-Times over 50 test runs
Input Size Best-Case Worst-Case Average-Case
N = 10000 1 15 1.78
N = 20000 3 8 3.4
N = 40000 6 9 6.7
Version 3 - Merge Sort and …