大家都说，Java性能现在已经很好啦，不能再抱着老观点去看它啦，甚至也有人说，Java性能已经超越C++了。我也相信Java虚拟机在不断优化，性能有很大提高，但要说它能超越C++，我想还是有相当难度的，当然，不排除在某些特殊情况下它能超越C++。不过眼见为实，耳听为虚，不想看那些所谓权威机构的测试结果，就自己动手吧，写几行代码权当消遣。呵呵，网上已经有人贴了这类测试代码，拿来改一下，我们就简单的计算平方和然后再取模就是了。代码写完，可以跑起来看看了。哦，我们的环境是：

Windows XP Professional Service Pack 3

Intel Core2 Duo CPU T7300 @ 2.00GHz

778MHz, 2GB RAM

Visual C++ 2008 Express Edition

java version "1.6.0_10-beta"

运行结果(运行时间，单位为秒)：

可以看到，对我的测试例而言，两者性能确实相差不大了，Java只比C++逊色那么一点点，对大多数应用而言，这点性能损失确实可以忽略不计了。

声明一下，测试结果严重依赖于测试用例，所以我的测试也不一定具有代表性，大家看看就好，不用太认真，:)

最后贴上测试用的源码：

C++代码：

#include "stdafx.h"

#include <iostream>

#include <windows.h>

using namespace std;

class TimeRecorder

{

public:

     TimeRecorder() { Start(); }

     void Start() { m_start = GetTickCount(); }

     void Stop() { m_end = GetTickCount(); }

     double GetInterval() { return (m_end - m_start)/1000.0; }

private:

     DWORD m_start;

     DWORD m_end;

};

int g_result;

double compute(int maxVal, int modNum)

{

     TimeRecorder timer;

     int result = 0;

     for (int i = 1; i < maxVal; i++)

     {

         result += i * i;

         result %= modNum;

     }

     // 有些ugly, 不过不加此句的话上面的计算过程会被完全忽略掉, 运行时间为0,

     g_result = result;

     timer.Stop();

     return timer.GetInterval();

}

int _tmain(int argc, _TCHAR* argv[])

{

     double time = 0.0;

     for (int i = 100000; i < 1000000; i += 100000)

     {

         for (int j = 100000; j < 1000000; j += 100000)

         {

              time += compute(i, j);

         }

     }

     cout << time << endl;

}

Java代码：

import java.util.Arrays;

public class GeneratePrimes

{

    public static double compute(int maxVal, int modNum)

    {

      long start = System.currentTimeMillis();

      int result = 0;

      for (int i = 1; i < maxVal; i++)

      {

        result += i * i;

        result %= modNum;

      }

      g_result = result;

      return (System.currentTimeMillis() - start)/1000.0;

    }

    public static void main(String args[])

    {

        double time = 0.d;

        for (int i = 100000; i < 1000000; i += 100000)

        {

          for (int j = 100000; j < 1000000; j += 100000)

          {

            time += compute(i, j);

          }

        }

        System.out.println(time);

    }

    public static int g_result;

}

C++是一种广泛使用的语言，也曾有兴趣略作研究。因为最近一段时间估计不会用它进行开发了，静下心来，谈谈我对它的理解或是发现。

(1) 引子

本文谈一谈C++中的隐式计数。隐式计数是一个计数器，因为他的储存空间没有显示的体现在程序代码中，故称之为“隐式”，而“计数”是说该存储空间的功能。这么一说，你首先想到的可能是C++中的new []和delete []操作符，不错，用new分配一个数组时，正是使用了“隐式计数”，才使得delete该数组指针时，能够获取到数组元素的个数，请看下面的代码，或许你并不陌生：

struct Test

{

Test() { cout << "Test()" << endl; }

~Test() { cout << "~Test()" << endl; }

};

int main()

{

Test *p = new Test[2];

*((int *)p - 1) = 1;

delete[] p;

return 0;

}

看看输出吧，构造函数被调用两次，析构函数被调用一次(在VC6.0和gcc中均是如此)，毫无疑问，(int *)p - 1的位置就是一个计数器，它记录了数组数组元素的个数。

(2) 示例1——string中的隐式计数

我们再来看看下面关于std::string的例子：

int main()

{

string s1("Hello");

string s2 = s1;

char *p = const_cast<char *>(s2.c_str());

p[0] = 'M';

cout << s1 << endl;

return 0;

}

上面的程序输出什么？是“Hello”吗？答案是不一定(我在gcc 3.4.6中是Mello)。这实际上取决于string类的实现，如果string采用了copy on write的机制，那么s1和s2实际上共享同一段内存，因此上面的代码也修改了s1的内容。当然，这都是const_cast惹的祸，常规代码对s1和s2都是能正常工作的。

上面提到了copy on write的共享机制，那么，程序又是如何决定什么时候删除该共享内存呢?答案是引用计数，如果你有兴趣，你可以查看p指针的前4个字节，发现其值为1，而再添加一个“string s3 = s1;”后，其值变为2，毫无疑问，这正是一个引用计数。

(3) 示例2——static中的隐式计数

再看一个关于static局部变量的例子。我们知道，如果函数中的static变量在定义时赋初值，那么只有在第一次调用该函数时，初始化才被执行，以后的调用都不再执行。那么，编译器又是怎么实现的呢？答案很简单，就是一个标志位，程序初始化时该标志位为0，函数中初始化相关的代码则演变为：检查标志位，如果是0，则对变量进行初始化，然后将标志位置1，否则跳过初始化步骤。这个标志位实际上就是一个隐式的计数器，虽然它只是一个0-1计数。

知道了编译器的这个“内幕”，你可以用下面的代码轻易的绕过初始化检查，让函数中的static变量在每次被调用时都被初始化(代码有些BT，不适者勿看)。

void Test(int initVal)

{

static int i = initVal;

cout << i << endl;

++i;

}

int FindAddress()

{

unsigned char *addr = (unsigned char *)&Test;

// There is only one instruction in Test: jmp realAddr

if (*addr == 0xe9)

{

addr = addr + *(int *)(addr + 1) + 5;

}

// Look forward at most 100 bytes for instruction "and eax 1"

for (int i = 0; i < 64; i++)

{

#ifdef WIN32

if (memcmp(addr + i, "\x83\xe0\x01", 3) == 0)

{

return *(int *)(addr + i - 4);

}

#else

if (addr[i+0] == 0x80 && addr[i+1] == 0x3d && addr[i+6] == 0x00)

{

return *(int *)(addr + i + 2);

}

#endif

}

return 0;

}

int main()

{

cout << "before modify: " << endl;

Test(0);

Test(100);

try

{

int flagAddress = FindAddress();

if (flagAddress)

{

cout << "After modify: " << endl;

*reinterpret_cast<int *>(flagAddress) = 0;

Test(1000);

}

else

{

cout << "Can not find the flag address" << endl;

}

}

catch (...)

{

cout << "There is some bug in program" << endl;

}

return 0;

}

代码的讲解我就不说了，注意的是FindAddress函数，其中尝试查找某种特征的指令。

(4) 总结

上面举了几个“隐式计数”的例子，它们可能是编译器为了在程序中实现代码面上的功能，而在其中添加的额外数据结构，也可能是库源码中为你所不熟悉的数据结构(如string中的隐式计数)。了解这些深层次的实现，对查排错误或是提高效率都不无裨益。

很少写文章，写这篇文章的目的，只是希望下次你在用到C++的某个比较“怪异”的特性时，也能有自己的发现, 。

对我们有用的是后半部分(也就是xentop第二次计算出的数据)，假设我们要提取VM1的CPU使用率，熟悉shell命令的知道，只需要使用下面的命令就可以了：
cat /tmp/xentop.tmp | grep VM1 | tail -n 1 | awk '{print \$4}'
而如果用perl来实现的话呢，一种很自然的处理方式是：先将xentop的结果按行进行split，然后对每一行进行分析，找到以VM1打头的最后一行，接着再将该行用空格进行split，最后取得结果中的第4项数据。呵呵，split就需要两次，也够麻烦的了。这个问题我跟dahong探讨了一下，他大体也是这个思路，不过他好像也不是perl的高级用户，:)
或许perl也有类似shell的“一行式”解决方法吧，只是我不知道而已，知道的告知一声啊，呵呵。