我试图测量执行这个循环的时间:
for (boolean t : test) {
if (!t)
++count;
}
结果不一致。最后,我设法通过以下代码获得了一致的结果:
public class Test {
public static void main(String[] args) {
int size = 100;
boolean[] test = new boolean[10_000_000];
java.util.Random r = new java.util.Random();
是否有任何函数/实用程序/工具可以解除给定次数的循环(n次迭代)的角色。(Java语言)
例如:实用程序必须在下一次循环中展开3次:
for(int i=0; i<10; i++){
int k = k + 1;
}
转换后的代码必须是:
k = k + 1;
k = k + 1;
k = k + 1;
for(int i=3; i<10; i++){
int k = k + 1;
}
谢谢伊塔玛。
鉴于这一守则:
class Foo {}
public class Test {
public Foo makeFoo(String p, String q) {
return new Foo(){
public void doSomething() {
System.out.println(p);
}
};
}
}
当您编译并运行java
在对Clojure应用程序进行基准测试并试图确定性能问题时,我注意到了这种奇怪的行为:即使整个程序是用Java编写的,从Leiningen启动时,它似乎也经历了明显的减速。
假设我有这个Java程序:
public class Foo {
public static void main(String[] args) throws Exception {
for (int i = 0; i < 10; i++)
run();
}
public static void run() {
final long s
我们正在使用Drools版本6.2.0来解析我们的一些规则。但有时当我们有大量运行时,Drools会调用JIT编译器,这会导致失败。我们已经在我们的Junit测试中涵盖了这一点,并且我们得到了以下错误
java.lang.NoSuchMethodError: org.mvel2.compiler.BlankLiteral.<init>(Ljava/lang/String;)V
at ConditionEvaluatoref4dc802b6174038b0307f5e6196e229.evaluate(Unknown Source)
at org.drools.core.rule.c
我试图确保一些(免费) java cpu分析工具的准确性,例如sjk、visualvm。
下面是一个执行cpu敏感任务的示例程序:
RandomStringUtils.java
import java.util.Random;
public class RandomStringUtils {
public String generate() {
int leftLimit = 97; // letter 'a'
int rightLimit = 122; // letter 'z'
int targetS
我试图找到一个简洁的示例,它在x86-64系统上用java显示。
我在for循环中使用y[i] = y[i] + x[i]实现了以下代码。这段代码可以从自动矢量化中受益,所以我认为java应该在运行时使用SSE或AVX指令编译它,以加快速度。
但是,我在生成的本机代码中找不到矢量化指令。
VecOpMicroBenchmark.java应该从自动矢量化中受益:
/**
* Run with this command to show native assembly:<br/>
* java -XX:+UnlockDiagnosticVMOptions
我是D的新手,我在简单的测试中将它与Java进行了比较,并期望看到本地语言会更快(或者大致相同)。但在我用递归D进行的第一次测试中,它比Java慢得多(几乎是Java的两倍)。
Java (这是一个糟糕的java性能测试,但它只是一个简单的想法):
public static void main(String... args) {
long before = System.nanoTime();
System.out.println(fibonacci(40));
System.out.println(TimeUnit.NANOSECONDS.t
假设jvm将b.foo()方法识别为热方法,它会尝试将其内联吗?因为如果这样做,调用指令B.bar()将在A.main方法中内联,这是禁止的,因为bar是私有的。jvm在这些情况下做什么?
任何有更多细节的文件也将不胜感激。谢谢
public class A {
public static void main(String[] args)
{
B b = new B();
for (int i=0; i<99999; i++)
b.foo();
}
}
class B {
public void
有没有办法控制Eclipse在构建项目时使用的java编译器的优化级别?或者这个问题不再重要了,是否所有的优化都被推迟到vm?
我问这个问题的原因是我最近写了一个快速测试来做这个:
private static int test_f(int i) { return i * 42; }
...
int z = 41;
for(int i = 0; i < 10000; ++i) { z = z*42; } // this loop runs in X seconds
for(int i = 0; i < 10000; ++i) { z = test_f(z); }
我得到了一个卡里珀基准,它看起来是这样的:
public Course timeCourseCreation( int i ) {
return createCourse( i );
}
public Course createCourse( int t ) {
Course course = new Course();
for ( int i = 0 + t; i < this.students + t; i++ ) {
Student student = new Student();
student.setAge( ( int ) ( 100 *
我用Runtime.getRuntime().totalMemory()和freeMemory()来计算内存。然而,我对结果感到困惑。
我已阅读了以下文章:
下面是我的演示代码:
package test;
class Memory
{
public static long used()
{
long total=Runtime.getRuntime().totalMemory();
long free=Runtime.getRuntime().freeMemory();
return (total-free);
}
}
package test;
import
我创建了一个简单的java程序:-
import java.util.ArrayList;
import java.util.List;
import java.lang.management.ManagementFactory;
public class OOMError {
public static List<Person> list = new ArrayList<>();
public static void main(String args[]){
System.out.println("Process Id:
我已经决定检查Java编译器的清晰性;因此,我编写了一个简单的类。
public class Foo {
public Foo(boolean a, int b) {
if (a == true && a != false) {
b = 1;
}
}
}
我想知道编译器是否会优化条件,使其变得更简单,比如:
if (a == true) {}
我编译了这个类,然后用javap工具对它进行了分解。当我查看输出时,我真的很困惑,因为编译器检查了这两种情况,如下所示。
Compiled from "Foo
考虑使用` `ObjectOutputStream‘序列化给定数量的对象的简单程序(发布在下面)。它多次调用相同的函数将对象序列化为文件。第一次调用比后续调用花费的时间更长(差异取决于被序列化的对象的数量):
Serializing 10000 objects...
Time elapsed: 498ms
Time elapsed: 168ms
Time elapsed: 186ms
Serializing 100000 objects...
Time elapsed: 1815ms
Time elapsed: 1352ms
Time elapsed: 1338ms
Serializing
考虑一下这个小班:
public class Example {
public int plus(int a){
int b;
b = 1;
return b+a;
}
}
javap说:
public int plus(int);
descriptor: (I)I
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=2
0: iconst_1
1: istore_2
2: iload_2
3: iload_1
4: iadd
5
后台:我的团队工作在一个程序上,它接受文本作为输入,处理它并显示结果。程序的每一次运行都是无状态的,并且独立于其他运行。我们注意到,在同一文本上循环运行处理方法时,第一次运行所需时间最长,下一次运行所需时间越来越少,直到几十次运行后的执行时间稳定下来,其值远低于初始运行时间。
我试图测试这是否是任何程序的普遍现象,并尝试运行具有嵌套循环的以下代码,并测量内循环所用的时间:
String s = "abcefghijklmnopqrstuvwxyz";
int TIMES = 10;
int INNER_TIMES = 1000000;
long count = 0;