`
starry198804265811
  • 浏览: 9916 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
文章分类
社区版块
存档分类
最新评论

我所做的Java和C++性能测试

CC++C#Java软件测试 
阅读更多

今天闲得无聊，突发奇想，做了一个Java和C++的性能对比测试。

 

1 测试方法

  很简单的，就是分别让Java程序和C++程序做很多次的整数和浮点数运算，然后测量测试代码段的运行时间。C++代码中使用Windows函数QueryPerformanceCounter() 获取CPU的高精度计数值，测试开始前后分别获取一次计数值，使用Windows函数QueryPerformanceFrequency()获取运行频率，前后的计数差值除以频率就得到了运行时间。为了使时间测量基准一致，在Java程序中通过JNI去调用这两个Windows函数，测量Java程序的运行时间。

  下面分别给出代码。

 

2 C++测试代码

 

#include "stdafx.h"
#include "windows.h"
#include <iostream>
#include <cmath>
using namespace std;

const int INT_C = 200000;
const int DOU_C = 50000;
const int MAIN_C = 10000;

class Test {
public:
	Test();
	void testInt();
	void testDouble();
	void doTest();
private:
	int m_i;
	double m_d;
};

Test::Test()
{
	m_i = 0;
	m_d = 0.0;
}

void Test::testInt()
{
	for (int i=1;i<= INT_C;i++) {
		m_i = (~(i*7) + 0x963 - i) & (i / 3);
	}
}

void Test::testDouble()
{
	for (int i=1;i<= DOU_C;i++) {
		m_d = ((i<<2) + 0.36954) * sin((double)i);
	}
}

void Test::doTest()
{
	testInt();
	testDouble();
}

int _tmain(int argc, _TCHAR* argv[])
{
	LARGE_INTEGER freq; 
	LARGE_INTEGER start;
	LARGE_INTEGER end;
	QueryPerformanceFrequency(&freq);

	Test* test = NULL;
	int j;

	cout<<"start test..."<<endl;

	QueryPerformanceCounter(&start);
	for (j = 0;j < MAIN_C; j++) {
		test = new Test();
		test->doTest();
		delete test;
	}
	QueryPerformanceCounter(&end);

	double druation = ((double)(end.QuadPart - start.QuadPart)) / ((double)freq.QuadPart);
	cout<<"Program run druation: "<<druation*1000<<" ms."<<endl;
	
	return 0;
}

 

 3 Java测试代码

3.1 测试代码

 

public class PerformTest {
	public static final int INT_C = 200000;
	public static final int DOU_C = 50000;
	public static final int MAIN_C = 10000;
	
	private int m_i;
	private double m_d;
	
	public void testInt() {
		for (int i=1;i<= INT_C;i++) {
			m_i = (~(i*7) + 0x963 - i) & (i / 3);
		}
	}
	
	public void testDouble() {
		for (int i=1;i<= DOU_C;i++) {
			m_d = ((i<<2) + 0.36954) * Math.sin((double)i);
		}
	}
	
	public void doTest() {
		testInt();
		testDouble();
	}
	
	public static void main(String[] args) {
		PerformanceTimer timer = new PerformanceTimer();
		PerformTest test = null;
		int j;
		System.out.println("start test...");
		
		timer.start();
		for (j = 0;j < MAIN_C; j++) {
			test = new PerformTest();
			test.doTest();
			test = null;
		}
		double duration = timer.end();
		
		System.out.println("Program run druation: " + duration + " ms.");
	}
}

 

 3.2 实现时间测量的代码

 

public class PerformanceTimer {
	private double freq;
	private double startTime;
	private double endTime;
	
	public PerformanceTimer() {
		this.freq = queryPerformanceFrequency();
	}
	
	private native double queryPerformanceFrequency();
	
	private native double QueryPerformanceCounter();
	
	public void start() {
		this.startTime = QueryPerformanceCounter();
	}
	
	public double end() {
		this.endTime = QueryPerformanceCounter();
		double duration = (endTime - startTime) / freq * 1000;
		return duration;
	}
	
	static {
		try {
			System.loadLibrary("PerformanceTimer");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

 3.3 实现时间测量的本地C++代码

    省略javah生成的头文件，给出实现的源文件。

 

#include "stdafx.h"
#include "windows.h"
#include "PerformanceTimer.h"

JNIEXPORT jdouble JNICALL Java_PerformanceTimer_queryPerformanceFrequency
  (JNIEnv *, jobject)
{
	LARGE_INTEGER freq;
	QueryPerformanceFrequency(&freq);

	return (double)(freq.QuadPart);
}

JNIEXPORT jdouble JNICALL Java_PerformanceTimer_QueryPerformanceCounter
  (JNIEnv *, jobject)
{
	LARGE_INTEGER counter;
	QueryPerformanceCounter(&counter);

	return (double)(counter.QuadPart);
}

 

 

4 测试结果

  我的软硬件环境：

  硬件配置：AMD AthlonII X3 435 2.89GHz; 2GB DDR3内存；WD 500G硬盘；

  软件环境：Windows7 旗舰版；Visual C++ 2008；SUN jdk1.6.0_21.

 

  C++测试结果：

 


 第一次 第二次 第三次 平均时间
时间（单位：ms） 21023.6 21003.5 21014.7

21013.9

 

  Java测试结果：

第一次 第二次 第三次 平均时间
时间（单位：ms） 94369.4 94317.3 94347.2 94344.6

 

C++程序的性能竟是Java的3倍？这真的是他们之间真实的性能差距吗？我所用的测试方法是否科学呢？那么影响我们的Java程序的性能瓶颈在什么地方？

分享到：
如何自定义ToolTip
评论
35 楼 yangyi 2011-05-24  
RednaxelaFX 写道
jellyfish 写道
java's sin() is slow comparing to c calls. Several years ago, I saw an article posting the comparing results, my runs came out almost the same results. It was about 60 times slow. Someone did some dig on the c side and found out ms did some optimization using assembly.
On the other hand, after digging the code on the java side, folks initiated a discusion with java's grandfather (you could google his name and sin function), then a debate came out as a big news.

Not sure about the performance of your code. Of course, there is always a hardware acceleration, such as GPU, but I am assuming we are in the context of the normal pc, since that's where I am working on everyday. You miles may vary.

That's "your mileage may vary". Learn, YMMV.

It's bad micro benchmarks that give people the wrong impression that Java is slow. A Java program may be slower than a well-tuned C program in a real world scenario, but that's got nothing to do with the those bad benchmarks are trying to tell you.

Go ahead and disassemble your /lib64/libm.so.6 equivalent, and see what "<sin>" turns into for yourself.

As for articles on Java's floating point arithmetic, I guess you're referring to something like this: How Java's Floating-Point Hurts Everyone Everywhere. That's from more than a decade ago, and the statements in it doesn't hold anymore now.


那么既然JVM是按照操作系统发布的，可以从本地调用和JVM实现和参数等方面调优，到底还存不存在因为跨平台而早成的性能损失呢，第一个想到的是swing，这个是不是也成了神话
34 楼 skzr.org 2011-05-24  
底层不懂，落伍了

一直提倡临时变量不要放到for外面，现代jvm已经解决了
现在都是直接在for里面用临时变量
实践中优点：
1. 可读性强
2. jvm帮忙优化了 ^ ^ 这个测试也佐证了 : ）
33 楼 RednaxelaFX 2011-05-24  
jellyfish 写道
java's sin() is slow comparing to c calls. Several years ago, I saw an article posting the comparing results, my runs came out almost the same results. It was about 60 times slow. Someone did some dig on the c side and found out ms did some optimization using assembly.
On the other hand, after digging the code on the java side, folks initiated a discusion with java's grandfather (you could google his name and sin function), then a debate came out as a big news.

Not sure about the performance of your code. Of course, there is always a hardware acceleration, such as GPU, but I am assuming we are in the context of the normal pc, since that's where I am working on everyday. You miles may vary.

That's "your mileage may vary". Learn, YMMV.

It's bad micro benchmarks that give people the wrong impression that Java is slow. A Java program may be slower than a well-tuned C program in a real world scenario, but that's got nothing to do with what those bad benchmarks are trying to tell you.

Go ahead and disassemble your /lib64/libm.so.6 equivalent, and see what "<sin>" turns into for yourself.

As for articles on Java's floating point arithmetic, I guess you're referring to something like this: How Java's Floating-Point Hurts Everyone Everywhere. That's from more than a decade ago, and the statements in it don't hold anymore now.
32 楼 RednaxelaFX 2011-05-24  
skzr.org 写道
刚才吃饭去了，其实就是根据lz的改了下。

用你的代码在我这边的Windows XP, JDK 6 update 25上跑是这样： 
C:\x>java -server PerformTest
start test[一次new]...
Program run druation[一次new]: 592.789 ms.
start test [每次new]...
Program run druation[每次new]: 587.895 ms.
start test[一次new]...
Program run druation[一次new]: 2100.829 ms.
start test [每次new]...
Program run druation[每次new]: 346.865 ms.
start test[一次new]...
Program run druation[一次new]: 335.599 ms.
start test [每次new]...
Program run druation[每次new]: 42.258 ms.
start test[一次new]...
Program run druation[一次new]: 335.614 ms.
start test [每次new]...
Program run druation[每次new]: 42.216 ms.
start test[一次new]...
Program run druation[一次new]: 335.665 ms.
start test [每次new]...
Program run druation[每次new]: 42.218 ms.


多加一个参数就不同了： 
C:\x>java -server -XX:LoopUnrollLimit=60 PerformTest
start test[一次new]...
Program run druation[一次new]: 598.998 ms.
start test [每次new]...
Program run druation[每次new]: 596.406 ms.
start test[一次new]...
Program run druation[一次new]: 560.527 ms.
start test [每次new]...
Program run druation[每次new]: 350.091 ms.
start test[一次new]...
Program run druation[一次new]: 42.605 ms.
start test [每次new]...
Program run druation[每次new]: 42.393 ms.
start test[一次new]...
Program run druation[一次new]: 42.391 ms.
start test [每次new]...
Program run druation[每次new]: 42.694 ms.
start test[一次new]...
Program run druation[一次new]: 42.259 ms.
start test [每次new]...
Program run druation[每次new]: 42.226 ms.

想说这例子再次印证了microbenchmark杯具的地方。你的环境里LoopUnrollLimit参数的默认值是60，而我的环境里这个值是50，就差那么一点但碰巧影响了一个优化——循环展开。

第三次之后变得特别快的原因，举例来说，main1()被编译后变成了近似这样： 
public static void main1() {
  System.out.println("start test [每次new]...");
  long start = System.nanoTime(); // 注意：无JNI的额外开销
  int j = 0;
  int i = 2;
  for (; i < 20001; i += 16) { // 步进为每轮循环16
  }
  for (; i < 20001; i++) {     // 剩余的部分步进为每轮循环1
  }
  for (; j < 10000; j++) {
  }
  long end = System.nanoTime(); // 注意：无JNI的额外开销
  System.out.println("Program run druation[每次new]: " + (end - start)/1000000d + " ms.");
}

可以看到，main1()里面调用doTest()、testInt()这些方法确实被内联了，逃逸分析+标量替换确实消除了new PerformTest()分配空间的需求，System.nanoTime()也的JNI调用开销也消除掉了（这是因为它在HotSpot VM里是个intrinsic）。实际上位移啊除法啊啥的时间都没测到，当然快。
可惜的就是那循环还在…

有兴趣看实际生成的代码我可以贴出来。主要是那控制流比较乱，读起来或许会比较费力…
31 楼 jellyfish 2011-05-24  
RednaxelaFX 写道
jellyfish 写道
Java's sin() function is slow, well known.

Slow, compared to what?
That's a well-known myth, which is not true for modern high performance JVMs like HotSpot, JRockit and J9. Unless you specify strictfp (which you would seldom see anyone do), these JVMs will take advantage of the floating point instructions of the underlying hardware for maximum performance. For example, this is what Math.sin() looks like when it's called from C2 compiled code, on x64: (C2 is the name of HotSpot's server compiler) 
StubRoutines::sin [0x00007f89ea1dcf11, 0x00007f89ea1dd029[ (280 bytes)
[Disassembling for mach='i386:x86-64']
  0x00007f89ea1dcf11: sub    $0x8,%rsp
  0x00007f89ea1dcf15: movsd  %xmm0,(%rsp)
  0x00007f89ea1dcf1a: fldl   (%rsp)
  0x00007f89ea1dcf1d: fldl   0x496451d(%rip)        # 0x00007f89eeb41440
  0x00007f89ea1dcf23: fld    %st(1)
  0x00007f89ea1dcf25: fabs   
  0x00007f89ea1dcf27: fucomip %st(1),%st
  0x00007f89ea1dcf29: ffree  %st(0)
  0x00007f89ea1dcf2b: fincstp 
  0x00007f89ea1dcf2d: ja     Stub::sin+41 0x0x7f89ea1dcf3a
  0x00007f89ea1dcf33: fsin   
  0x00007f89ea1dcf35: jmpq   Stub::sin+267 0x0x7f89ea1dd01c
  0x00007f89ea1dcf3a: mov    %rsp,-0x28(%rsp)
  0x00007f89ea1dcf3f: sub    $0x80,%rsp
  0x00007f89ea1dcf46: mov    %rax,0x78(%rsp)
  0x00007f89ea1dcf4b: mov    %rcx,0x70(%rsp)
  0x00007f89ea1dcf50: mov    %rdx,0x68(%rsp)
  0x00007f89ea1dcf55: mov    %rbx,0x60(%rsp)
  0x00007f89ea1dcf5a: mov    %rbp,0x50(%rsp)
  0x00007f89ea1dcf5f: mov    %rsi,0x48(%rsp)
  0x00007f89ea1dcf64: mov    %rdi,0x40(%rsp)
  0x00007f89ea1dcf69: mov    %r8,0x38(%rsp)
  0x00007f89ea1dcf6e: mov    %r9,0x30(%rsp)
  0x00007f89ea1dcf73: mov    %r10,0x28(%rsp)
  0x00007f89ea1dcf78: mov    %r11,0x20(%rsp)
  0x00007f89ea1dcf7d: mov    %r12,0x18(%rsp)
  0x00007f89ea1dcf82: mov    %r13,0x10(%rsp)
  0x00007f89ea1dcf87: mov    %r14,0x8(%rsp)
  0x00007f89ea1dcf8c: mov    %r15,(%rsp)
  0x00007f89ea1dcf90: sub    $0x8,%rsp
  0x00007f89ea1dcf94: fstpl  (%rsp)
  0x00007f89ea1dcf97: movsd  (%rsp),%xmm0
  0x00007f89ea1dcf9c: test   $0xf,%esp
  0x00007f89ea1dcfa2: je     Stub::sin+169 0x0x7f89ea1dcfba
  0x00007f89ea1dcfa8: sub    $0x8,%rsp
  0x00007f89ea1dcfac: callq  0x00007f89eea45d76
  0x00007f89ea1dcfb1: add    $0x8,%rsp
  0x00007f89ea1dcfb5: jmpq   Stub::sin+174 0x0x7f89ea1dcfbf
  0x00007f89ea1dcfba: callq  0x00007f89eea45d76
  0x00007f89ea1dcfbf: movsd  %xmm0,(%rsp)
  0x00007f89ea1dcfc4: fldl   (%rsp)
  0x00007f89ea1dcfc7: add    $0x8,%rsp
  0x00007f89ea1dcfcb: mov    (%rsp),%r15
  0x00007f89ea1dcfcf: mov    0x8(%rsp),%r14
  0x00007f89ea1dcfd4: mov    0x10(%rsp),%r13
  0x00007f89ea1dcfd9: mov    0x18(%rsp),%r12
  0x00007f89ea1dcfde: mov    0x20(%rsp),%r11
  0x00007f89ea1dcfe3: mov    0x28(%rsp),%r10
  0x00007f89ea1dcfe8: mov    0x30(%rsp),%r9
  0x00007f89ea1dcfed: mov    0x38(%rsp),%r8
  0x00007f89ea1dcff2: mov    0x40(%rsp),%rdi
  0x00007f89ea1dcff7: mov    0x48(%rsp),%rsi
  0x00007f89ea1dcffc: mov    0x50(%rsp),%rbp
  0x00007f89ea1dd001: mov    0x60(%rsp),%rbx
  0x00007f89ea1dd006: mov    0x68(%rsp),%rdx
  0x00007f89ea1dd00b: mov    0x70(%rsp),%rcx
  0x00007f89ea1dd010: mov    0x78(%rsp),%rax
  0x00007f89ea1dd015: add    $0x80,%rsp
  0x00007f89ea1dd01c: fstpl  (%rsp)
  0x00007f89ea1dd01f: movsd  (%rsp),%xmm0
  0x00007f89ea1dd024: add    $0x8,%rsp
  0x00007f89ea1dd028: retq

in the fastest case, the code above boils down to: 
StubRoutines::sin [0x00007f89ea1dcf11, 0x00007f89ea1dd029[ (280 bytes)
[Disassembling for mach='i386:x86-64']
  0x00007f89ea1dcf11: sub    $0x8,%rsp
  0x00007f89ea1dcf15: movsd  %xmm0,(%rsp)
  0x00007f89ea1dcf1a: fldl   (%rsp)
  0x00007f89ea1dcf1d: fldl   0x496451d(%rip)        # 0x00007f89eeb41440
  0x00007f89ea1dcf23: fld    %st(1)
  0x00007f89ea1dcf25: fabs   
  0x00007f89ea1dcf27: fucomip %st(1),%st
  0x00007f89ea1dcf29: ffree  %st(0)
  0x00007f89ea1dcf2b: fincstp 
  0x00007f89ea1dcf2d: ja     Stub::sin+41 0x0x7f89ea1dcf3a
  0x00007f89ea1dcf33: fsin   
  0x00007f89ea1dcf35: jmpq   Stub::sin+267 0x0x7f89ea1dd01c
# ...
  0x00007f89ea1dd01c: fstpl  (%rsp)
  0x00007f89ea1dd01f: movsd  (%rsp),%xmm0
  0x00007f89ea1dd024: add    $0x8,%rsp
  0x00007f89ea1dd028: retq

even better, it doesn't have to invoke a stub all the time; the code may be inlined to the call site, resulting in code like this: 
  0x00007f89ea1fa92b: sub    $0x8,%rsp
  0x00007f89ea1fa92f: movsd  %xmm0,(%rsp)
  0x00007f89ea1fa934: data16
  0x00007f89ea1fa935: fldl   (%rsp)
  0x00007f89ea1fa938: fsin   
  0x00007f89ea1fa93a: fstpl  0x0(%rsp)
  0x00007f89ea1fa93e: movsd  (%rsp),%xmm0
  0x00007f89ea1fa943: add    $0x8,%rsp

which isn't as slow as you might guess it is.


java's sin() is slow comparing to c calls. Several years ago, I saw an article posting the comparing results, my runs came out almost the same results. It was about 60 times slow. Someone did some dig on the c side and found out ms did some optimization using assembly.
On the other hand, after digging the code on the java side, folks initiated a discusion with java's grandfather (you could google his name and sin function), then a debate came out as a big news.

Not sure about the performance of your code. Of course, there is always a hardware acceleration, such as GPU, but I am assuming we are in the context of the normal pc, since that's where I am working on everyday. You miles may vary.

30 楼 ppgunjack 2011-05-24  
这种测试很难说明问题
我机器上用gcc把new的Test换成栈上生成，-O3的情况下，循环内的doTest甚至直接被优化掉了
生成对象，这里的实现根本不会产生内存碎片，也不存在对查找free块的损耗，并且构造成本对于double那些test运算成本基本是边际成本
去掉jni实际两者的速度差别很小
有意义的是拿查询或者一些算法做测试，确保每行代码都是要起作用的
并且这个和OS，cpu，编译器，编译选项，jvm版本依赖很大，纯计算的代码我笔记本上c++一般都还能保持10%-20%的优势，家里台式机基本都是5%以内，涉及字符串的代码，如果c++不是用char*而是string,经常会比java还慢
29 楼 skzr.org 2011-05-24  
RednaxelaFX，你说得确实有道理，虽然这个jvm优化，但是确实不能带来特别的性能提升。

钦佩里的追求精神 ^ ^
28 楼 skzr.org 2011-05-24  
<div class="quote_title">RednaxelaFX 写道</div>
<div class="quote_div">
<div class="quote_title">skzr.org 写道</div>
<div class="quote_div">实际上对于java进行浮点运算有点难度，我注释了testDouble重新测试结果如下：非常<span style="color: red;"><strong>好奇为什么从第3次开始速度超级快</strong></span>
</div>
<br>你测试用的具体代码和参数是怎样的呢？<br><br>这种microbenchmark的重大缺陷就是：它太小了，而且不“真实”，得到什么数据都好对实际程序来说意义都有限；更糟糕的是很小的细节可以大幅度影响这种小测试的结果数据。所以把完整的测试代码帖出来吧，想要分析里面的点的话。<br><br>多半是因为你的测试到第三次开始进入达成了标量替换的优化编译版本，而里面的testInt()变成了类似这种样子：<br><pre name="code" class="java">for (int i = 0; i &lt; INT_C; i++) ;</pre>
</div>
<div class="quote_div">
<br>因为计算的结果没用过所以循环体整个消除了。要验证是不是真的如此就等楼上贴了完整测试代码再说。<br><br>可惜的是循环本身没有整个消除掉，不然效果更佳 XD</div>
<p> </p>
<p>刚才吃饭去了，其实就是根据lz的改了下。</p>
<p> </p>
<pre name="code" class="java">public class PerformTest {
public static final int INT_C = 200000;
public static final int DOU_C = 50000;
public static final int MAIN_C = 10000;

private int m_i;
private double m_d;

public void testInt() {
for (int i=1;i&lt;= INT_C;i++) {
m_i = (~(i*7) + 0x963 - i) &amp; (i / 3);
}
}

public void testDouble() {
for (int i=1;i&lt;= DOU_C;i++) {
m_d = ((i&lt;&lt;2) + 0.36954) * Math.sin((double)i);
}
}

public void doTest() {
testInt();
//testDouble();&lt;----------这里被注释了
}

public static void main(String[] args) {
main2();
main1();
main2();
main1();
main2();
main1();
main2();
main1();
main2();
main1();
}

public static void main1() {
PerformTest test = null;
int j;
System.out.println("start test [每次new]...");
long end, start = System.nanoTime();
for (j = 0;j &lt; MAIN_C; j++) {
test = new PerformTest();
test.doTest();
}
end = System.nanoTime();
System.out.println("Program run druation[每次new]: " + (end - start)/1000/1000d + " ms.");
}

public static void main2() {
PerformTest test = new PerformTest();
int j;
System.out.println("start test[一次new]...");
long end, start = System.nanoTime();
for (j = 0;j &lt; MAIN_C; j++) {
test.doTest();
}
end = System.nanoTime();
System.out.println("Program run druation[一次new]: " + (end - start)/1000/1000d + " ms.");
}
}</pre>
 
<p> </p>
27 楼 RednaxelaFX 2011-05-24  
skzr.org 写道
实际上对于java进行浮点运算有点难度，我注释了testDouble重新测试结果如下：非常好奇为什么从第3次开始速度超级快

你测试用的具体代码和参数是怎样的呢？

这种microbenchmark的重大缺陷就是：它太小了，而且不“真实”，得到什么数据都好对实际程序来说意义都有限；更糟糕的是很小的细节可以大幅度影响这种小测试的结果数据。所以把完整的测试代码帖出来吧，想要分析里面的点的话。

多半是因为你的测试到第三次开始进入达成了标量替换的优化编译版本，而里面的testInt()变成了类似这种样子：
for (int i = 0; i < INT_C; i++) ;

因为计算的结果没用过所以循环体整个消除了。要验证是不是真的如此就等楼上贴了完整测试代码再说。

可惜的是循环本身没有整个消除掉，不然效果更佳 XD
26 楼 skzr.org 2011-05-24  
<div class="quote_title">RednaxelaFX 写道</div>
<div class="quote_div">
<div class="quote_title">skzr.org 写道</div>
<div class="quote_div">不过你的代码里面：<br><pre name="code" class="java"> public static long driveTest() {
long start = System.nanoTime();
for (int j = 0; j &lt; MAIN_C; j++) {
PerformTest test = new PerformTest();
test.doTest();
test = null;
}
long end = System.nanoTime();
return end - start;
}</pre>
<br>还是一样的new了对象了的？不知道你这里：“在我说的条件下执行的话就不会new那么多对象出来”</div>
<br>是的，这就是为什么我强调“在我说的条件下”。<br>请参考这帖：<a href="http://rednaxelafx.iteye.com/blog/659108" target="_blank">http://rednaxelafx.iteye.com/blog/659108</a><br>昨晚发代码之前我在Linux/x64上的JDK 6 update 25用这份代码做过测试，观察了JIT编译后生成的代码，确认标量替换成功从而消除了PerformTest的创建。如果对细节有兴趣的话我可以把生成的代码贴出来。<br>InlineSmallCode参数是在测试的时候调整得到的值。这个值在我的环境里必须要大于1200左右才足以完成这里说的优化。为了保险我是建议设置为2000。<br><br><span style="color: #ff0000; font-size: small;"><strong>如果对此优化感觉很玄乎的话，</strong></span>可以试试自己做这个实验。由于改动后这例子创建的对象数本来就不多，所以不方便通过-verbose:gc来观察标量替换的效果。换个方式，通过jstat -gcutil来观察。<br>
</div>
<p> </p>
<p>兄弟赞叹一个，不亏来自杭州的。</p>
<p>看了你的参考贴确实并买了“标量替换和内联”，不过正如你所说的<span style="color: #ff0000; font-size: medium;"><strong>对此优化感觉很玄乎</strong></span>，这个确实让我纠结 ^ ^</p>
<p>我的观点：</p>
<p>1. c++效率和运行速度上应该比java快</p>
<p>2. java在开发设计中速度比c++快</p>
<p> </p>
<p>环境：ubuntu10.10 64bit, cpu: core2 P8400, jvm: jdk1.6.0_24: -server -Xms128M</p>
<p> </p>
<p>不重复创建对象 vs 重复创建对象我的测试——确实差距不大。</p>
<p> </p>
<p> </p>
<pre name="code" class="java">start test[一次new]...
Program run druation[一次new]: 59050.926 ms.
start test [每次new]...
Program run druation[每次new]: 59085.349 ms.

start test[一次new]...
Program run druation[一次new]: 59100.275 ms.
start test [每次new]...
Program run druation[每次new]: 59171.323 ms.

start test[一次new]...
Program run druation[一次new]: 59196.806 ms.
start test [每次new]...
Program run druation[每次new]: 59386.498 ms.

start test[一次new]...
Program run druation[一次new]: 59150.217 ms.
start test [每次new]...
Program run druation[每次new]: 59140.532 ms.

start test[一次new]...
Program run druation[一次new]: 59134.399 ms.
start test [每次new]...
Program run druation[每次new]: 59160.485 ms.
</pre>
 
<p> </p>
<p> </p>
<p>实际上对于java进行浮点运算有点难度，我注释了testDouble重新测试结果如下：非常<span style="color: #ff0000;"><strong>好奇为什么从第3次开始速度超级快</strong></span></p>
<p> </p>
<p> </p>
<pre name="code" class="java">start test[一次new]...
Program run druation[一次new]: 518.487 ms.
start test [每次new]...
Program run druation[每次new]: 503.69 ms.

start test[一次new]...
Program run druation[一次new]: 469.589 ms.
start test [每次new]...
Program run druation[每次new]: 301.692 ms.

start test[一次new]...
Program run druation[一次new]: 53.419 ms.
start test [每次new]...
Program run druation[每次new]: 54.958 ms.

start test[一次new]...
Program run druation[一次new]: 54.331 ms.
start test [每次new]...
Program run druation[每次new]: 54.174 ms.

start test[一次new]...
Program run druation[一次new]: 54.417 ms.
start test [每次new]...
Program run druation[每次new]: 54.013 ms.
</pre>
 
<p> </p>
<p> </p>
<p> </p>
25 楼 xuby 2011-05-24  
问下楼主，c++代码的编译选项（主要是优化选项）是什么？
24 楼 nobody2008 2011-05-24  
xuby 写道
怎么每个帖子说风凉话都多于认真做讨论的。
楼主辛苦些这些代码，做测试，然后贴出来跟大家分享，无论如何都是值得尊重的。至少楼主验证了在所给出的案例下，c++和Java的性能差别。
如果你认为楼主的水平很差，或者工作毫无价值，那你可以到水平高，或者比较有聊的帖子里去讨论。完全用不着去说风凉话。
现在愿意做这些貌似微不足道的测试的人，不是太多了，而是太少了。不知道这跟风凉话有没有关系。

我也没知道java比c++性能差，可是从来没有测试过。一方面c，c++只会一些基本的语法，另一方面就是懒。
谢谢 作者。

不过三倍已经超值得安慰了（对我这句话不屑一顾甚至嗤之以鼻的朋友，建议先了解他们以前效率差距多大；编译语言和解释语言效率差距多大）。
23 楼 放开那个大妈 2011-05-24  
这是不是还要跟测试的环境有关系？
22 楼 心尘如梦 2011-05-24  
貌似并不能代表一切
21 楼 RednaxelaFX 2011-05-24  
skzr.org 写道
不过你的代码里面：
	public static long driveTest() {
		long start = System.nanoTime();
		for (int j = 0; j < MAIN_C; j++) {
			PerformTest test = new PerformTest();
			test.doTest();
			test = null;
		}
		long end = System.nanoTime();
		return end - start;
	}

还是一样的new了对象了的？不知道你这里：“在我说的条件下执行的话就不会new那么多对象出来”

是的，这就是为什么我强调“在我说的条件下”。
请参考这帖：http://rednaxelafx.iteye.com/blog/659108
昨晚发代码之前我在Linux/x64上的JDK 6 update 25用这份代码做过测试，观察了JIT编译后生成的代码，确认标量替换成功从而消除了PerformTest的创建。如果对细节有兴趣的话我可以把生成的代码贴出来。
InlineSmallCode参数是在测试的时候调整得到的值。这个值在我的环境里必须要大于1200左右才足以完成这里说的优化。为了保险我是建议设置为2000。

如果对此优化感觉很玄乎的话，可以试试自己做这个实验。由于改动后这例子创建的对象数本来就不多，所以不方便通过-verbose:gc来观察标量替换的效果。换个方式，通过jstat -gcutil来观察。

这是我在32位Windows，JDK 6 update 25上跑的一组日志：
C:\x>java -server -verbose:gc -XX:+PrintCompilation -XX:InlineSmallCode=2000 -Xm
x2m -Xms2m -Xmn1m PerformTest

  23587   1%      PerformTest::testInt @ 2 (35 bytes)
  23593   2%      PerformTest::testDouble @ 2 (33 bytes)
  23598   1       PerformTest::testInt (35 bytes)
  23598   2       PerformTest::testDouble (33 bytes)
  59118   3       java.lang.Object::<init> (1 bytes)
  66767   4       PerformTest::<init> (5 bytes)
  66767   5       PerformTest::doTest (9 bytes)
  66772   6       PerformTest::driveTest (41 bytes)
  91193   3%      PerformTest::driveTest @ 6 (41 bytes)
start test...
Program run duration: 42922.538731 ms.

虽然已经把堆设置得很小，但本来创建的对象就不多所以这个例子里看不到GC的日志。
同步收集的jstat -gcutil则是：
C:\x>jps
3144 PerformTest
3896 Jps

C:\x>jstat -gcutil 3144 1s
  S0     S1     E      O      P     YGC     YGCT    FGC    FGCT     GCT
  0.00   0.00  30.85   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  30.85   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  30.85   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  30.85   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  31.08   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  31.79   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  32.48   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  33.19   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  33.91   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  34.59   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  35.31   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  36.03   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  36.75   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  37.43   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  38.15   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  38.87   0.00  13.00      0    0.000     0    0.000    0.000
  0.00   0.00  39.55   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  40.26   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  40.98   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  41.66   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  42.38   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  43.10   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  43.78   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  44.50   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  45.22   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  45.94   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  46.62   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  47.34   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  48.06   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  48.74   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  49.46   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  50.18   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  50.86   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  51.58   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  52.29   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  52.98   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  53.69   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  54.41   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  55.13   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  55.81   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  56.53   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  57.24   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  57.93   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  58.64   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  59.36   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  59.95   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  60.50   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  61.08   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  61.66   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  62.21   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  62.79   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  63.37   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  63.92   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  64.50   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  65.08   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  65.63   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  66.20   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  66.78   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  67.36   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  67.91   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  68.49   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  69.07   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  69.62   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  70.20   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  70.78   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  71.33   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  71.91   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  72.49   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  73.07   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  73.61   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  74.19   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  74.77   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  75.31   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  75.89   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  76.47   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000
  0.00   0.00  78.48   0.00  13.01      0    0.000     0    0.000    0.000

这是整个测试过程的完整日志。可以看到，经过开头一段时间后，eden的使用空间就没有再增加过；中间从76.47%到78.48%的那一条是 System.out.println("start test..."); 过程中产生的中间对象造成的，跟 driveTest() 内的代码无关。
20 楼 skzr.org 2011-05-24  
<div class="quote_title">xuby 写道</div>
<div class="quote_div">怎么每个帖子说风凉话都多于认真做讨论的。<br>楼主辛苦些这些代码，做测试，然后贴出来跟大家分享，无论如何都是值得尊重的。至少楼主验证了在所给出的案例下，c++和Java的性能差别。<br>如果你认为楼主的水平很差，或者工作毫无价值，那你可以到水平高，或者比较有聊的帖子里去讨论。完全用不着去说风凉话。<br>现在愿意做这些貌似微不足道的测试的人，不是太多了，而是太少了。不知道这跟风凉话有没有关系。</div>
<p> </p>
<p>套测试的是计算性能，不过new的消耗，对比计算性能而言是巨大的，所以不要在循环中new对象，然后再测试这样的结果更好。</p>
19 楼 skzr.org 2011-05-24  
<div class="quote_title">RednaxelaFX 写道</div>
<div class="quote_div">
<div class="quote_title">skzr.org 写道</div>
<div class="quote_div">
<pre name="code" class="java">for (j = 0;j &lt; MAIN_C; j++) {   
    test = new PerformTest();   
    test.doTest();   
    test = null;   
}</pre>
<br><br>你这里还测试了new 10000次的对象，如果只是做计算的能力对比建议不要new 10000个，只new 1个进行测试更好<br>因为new的操作相比于计算还是比较耗的</div>
<br>如果用我前面给的后一个版本的代码，在我说的条件下执行的话就不会new那么多对象出来。逃逸分析+标量替换解决了这个问题。InlineSmallCode=2000在这个实验里加不加会有影响。</div>
<p> </p>
<p>不过你的代码里面：</p>
<p><span style=""><ol class="dp-j" style="font-size: 1em; line-height: 1.4em; margin-top: 0px; margin-right: 0px; margin-bottom: 1px; margin-left: 0px; padding-top: 2px; padding-right: 0px; padding-bottom: 2px; padding-left: 0px; background-color: #ffffff; color: #2b91af; border: 1px solid #d1d7dc;">
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;"> <span class="keyword" style="color: #7f0055; font-weight: bold;">public</span><span style="color: black;"> </span><span class="keyword" style="color: #7f0055; font-weight: bold;">static</span><span style="color: black;"> </span><span class="keyword" style="color: #7f0055; font-weight: bold;">long</span><span style="color: black;"> driveTest() {  </span></span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">        <span class="keyword" style="color: #7f0055; font-weight: bold;">long</span><span style="color: black;"> start = System.nanoTime();  </span></span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">        <span class="keyword" style="color: #7f0055; font-weight: bold;">for</span><span style="color: black;"> (</span><span class="keyword" style="color: #7f0055; font-weight: bold;">int</span><span style="color: black;"> j = </span><span class="number" style="color: #c00000;">0</span><span style="color: black;">; j &lt; MAIN_C; j++) {  </span></span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">            PerformTest test = <span class="keyword" style="color: #7f0055; font-weight: bold;">new</span><span style="color: black;"> PerformTest();  </span></span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">            test.doTest();  </span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">            test = <span class="keyword" style="color: #7f0055; font-weight: bold;">null</span><span style="color: black;">;  </span></span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">        }  </span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">        <span class="keyword" style="color: #7f0055; font-weight: bold;">long</span><span style="color: black;"> end = System.nanoTime();  </span></span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">        <span class="keyword" style="color: #7f0055; font-weight: bold;">return</span><span style="color: black;"> end - start;  </span></span></li>
<li style="font-size: 1em; margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 38px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 10px; border-left-width: 1px; border-left-style: solid; border-left-color: #d1d7dc; background-color: #fafafa; line-height: 18px;"><span style="color: black;">    }  </span></li>
</ol></span></p>
<p>还是一样的new了对象了的？不知道你这里：“在我说的条件下执行的话就不会new那么多对象出来”</p>
<p> </p>
18 楼 xuby 2011-05-24  
怎么每个帖子说风凉话都多于认真做讨论的。
楼主辛苦些这些代码，做测试，然后贴出来跟大家分享，无论如何都是值得尊重的。至少楼主验证了在所给出的案例下，c++和Java的性能差别。
如果你认为楼主的水平很差，或者工作毫无价值，那你可以到水平高，或者比较有聊的帖子里去讨论。完全用不着去说风凉话。
现在愿意做这些貌似微不足道的测试的人，不是太多了，而是太少了。不知道这跟风凉话有没有关系。
17 楼 jjkingwei 2011-05-24  
无聊的测试，还不如好好说说某一个语言的编程优化...
16 楼 悲剧了 2011-05-24  
代码大全里面说：性能跟你的机器，跟你的环境，用到的相关版本有关，一般就是前期写程序不需要太考虑性能，写出好读逻辑清晰的代码，后期根据特定环境做分析，真正性能设计到的代码只有百分之二，而这百分之二写编码时候是不用费大力气，却在不确定因素上花时间
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java 调用C++库测试代码

    Java调用C++库是跨语言交互的一种常见方式，主要依赖于...这种跨语言交互机制使得开发者能够灵活地结合Java的平台独立性和C++的高效性能。在实际项目中，这样的技术常用于游戏开发、高性能计算以及与硬件交互等场景。

    C++库封装JNI接口-实现java调用c++

    在跨平台的软件开发中，有时我们需要在Java和C++之间进行交互，这通常是由于性能需求、使用已有的C++库或特定硬件接口的原因。Java Native Interface (JNI) 是Java平台提供的一种机制，允许Java代码和其他语言写的...

    现代多线程 JAVA和c++多线程实现 测试和调试

    本资源主要探讨了如何在JAVA和C++中实现多线程，以及相关的测试和调试技术。 在JAVA中，多线程的实现主要依赖于`Thread`类和`Runnable`接口。开发者可以通过直接继承`Thread`类或实现`Runnable`接口来创建新的线程...

    C++代码转java工具

    在实际使用这种工具时，开发者应该了解转换的局限性，理解哪些部分可能需要手动调整，以及如何测试和验证转换后的代码以确保功能正确性和性能。此外，对于复杂的C++项目，转换可能不是最佳解决方案，因为可能会丢失...

    java、c++、软件测试面试题

    5. **性能测试**：了解压力测试、负载测试、稳定性测试，使用工具如JMeter进行性能评估。 6. **敏捷开发与持续集成**：熟悉敏捷开发理念，如Scrum和Kanban，以及持续集成工具如Jenkins的应用。 7. **测试文档**：...

    C++转换JAVA工具

    2. **混合编程**：如果一个项目需要C++的高性能部分和Java的跨平台优势，转换工具可以用来创建接口，使两者协同工作。 3. **学习和理解**：开发者可以通过查看转换后的代码，更好地理解和学习两种语言的异同。 在...

    JAVA调用C++编写的DLL(C++和JAVA源码)

    总结，通过理解并运用JNI，我们可以将Java的易用性和C++的高性能结合起来，实现更高效的应用程序。提供的压缩包"Java_TypeSwitch_Dll"可能包含了示例代码，通过学习和实践这些例子，你将更好地掌握Java调用C++ DLL的...

    C++ JAVA 软件测试面试题汇总

    在软件开发领域，C++和Java是两种广泛使用的编程语言，尤其在企业级应用和系统级编程中。软件测试则是确保这些程序质量的关键环节。...通过学习和解答这些题目，可以提升对C++、Java和软件测试的理解，增强面试竞争力。

    C++转Java工具

    文件列表中包含了"C++ to Java Converter.exe.config"和"C++ to Java Converter.exe"。前者是应用程序的配置文件，通常用于存储应用程序运行时的设置，比如数据库连接字符串、日志级别等。而后者是可执行文件，即...

    JAVA调用C++demo

    这种方式虽然增加了项目的复杂性，但能充分发挥Java的跨平台特性和C++的高性能优势，是解决特定问题的有效途径。在实际开发中，需要对Java、C++以及JNI有深入的理解，才能更好地驾驭这种混合编程模式。

    C++单元测试、压力测试、快速测试工具

    在IT行业中，单元测试、压力测试和快速测试是软件开发过程中的重要环节，尤其是在使用C++这样的编程语言时。这些测试方法确保了代码的质量、稳定性和性能，为开发者提供了信心，保证了软件产品的可靠性。本篇文章将...

    C++调用Java接口

    这将创建一个C++头文件，其中包含Java方法的声明和JNI所需的函数原型。假设我们有一个名为`com_example_JavaApp`的Java包，那么命令可能是这样的： ``` javah -jni com.example.JavaApp.JavaInterface ``` 这...

    C++、JAVA+、C+++、软件测试面试题

    在IT行业中，C++、Java++（这里可能是Java的误写，通常我们只说Java）、C++以及软件测试是至关重要的领域，它们构成了现代软件开发的基石。面试题集是评估求职者技能的重要工具，因此深入理解这些领域的关键概念和...

    java调用c++生成dll

    6. **调试与测试**：使用Java调试器和C++调试器（如Visual Studio的调试器）配合，可以分别在Java和C++层面进行调试，确保问题定位准确。 总的来说，Java调用C++生成的DLL涉及到JNI规范、C++编程、Windows动态库...

    java 调用C++ 动态库

    9. **测试与调试**: 测试Java调用C++的完整流程，确保数据传输正确无误，同时利用C++和Java的调试工具进行问题定位。 总结来说，Java调用C++动态库是一个涉及多步骤的过程，包括生成JNI头文件、编写C++代码、编译...

    Java调用C++的dll之-C++工程

    在IT行业中，跨语言通信是一...通过这样的方式，我们可以充分利用C++的性能优势和Java的跨平台特性，实现两者的高效协作。在实际项目中，这样的跨语言调用常用于高性能计算、利用现有C++库或者实现特定硬件驱动等功能。

    软件测试题大全（Java，c++）

    本资源“软件测试题大全（Java，c++）”汇聚了丰富的测试题目和测试用例，旨在帮助Java和C++开发者及测试工程师提升自己的技能，理解测试的核心原理和实践方法。以下是根据标题、描述以及可能包含的文件内容，对软件...

    C 、JAVA 、C++ 、软件测试面试题

    在IT行业中，编程语言如C、Java和C++以及软件测试是至关重要的领域，它们各自拥有丰富的知识体系，且在实际工作和面试中都扮演着关键角色。下面将分别介绍这些知识点，帮助读者理解并应对相关面试题。 一、C语言 ...

    Java和c++互相回调的例子

    9. **性能考虑**: 虽然JNI提供了Java和C++的互操作性，但频繁的Java到C++的调用可能会引入额外的性能开销，因为涉及到了Java对象到本地数据的转换。因此，在设计系统时，应谨慎考虑这些调用的频率和复杂性。 10. **...

    java调用c++ dll的示例

    7. **测试和调试**: 编译C++代码，生成DLL，然后在Java程序中进行测试。确保所有必要的库和依赖项都被正确地添加到运行环境。调试时，可以在C++端使用传统的C++调试器，而在Java端使用JVM的调试工具。 在提供的...

Magicbox
Global site tag (gtag.js) - Google Analytics