/etc/httpd/conf/httpd.conf，发现没有定义 .jad 和 .jar 文件的语句，于是添加如下两行：然后重启 Apache 服务，问题解决。MIDlet 成功在 SAMSUNG SGH-L760 上安装了。AddType text/vnd.sun.j2me.app-descriptor .jad
AddType application/vnd.sun.j2me.java-archive .jar
for() 循环内的代码，循环多少次，它们就被执行多少次。因此，为了改进性能，我们需要尽可能的把代码放在循环之外。我们在描述器中会发现我们的 paint() 方法被调用了 101 次，并且循环执行了 16 次。我们可以把哪些东西放在循环之外呢？让我们从所有的声明(declaration)开始。每次调用 paint() 方法，我们都声明了一个 Font，一个 String，一个 Image 以及一个 Graphics 对象。我们可以将这些从该方法中挪出来，放到类的顶部。 public static final Font font =
Font.getFont( Font.FACE_PROPORTIONAL,
Font.STYLE_BOLD Font.STYLE_ITALIC,
Font.SIZE_SMALL);
public static final int graphicAnchor =
Graphics.VCENTER Graphics.HCENTER;
public static final int textAnchor =
Graphics.TOP Graphics.LEFT;
private static final String MESSAGE = " ms per frame";
private String msMessage = "000" + MESSAGE;
private Image stringImage;
private Graphics imageGraphics;
private long oldFrameTime;
Font 对象设置成为共有的常量。这在程序中通常很有用，比如这里你可以把常用到的字体在同一个地方集中定义。我发现锚(anchor)也是一样，因此对文字以及图形的锚也做了同样的处理。预先计算这些东西，保证了计算的结果，虽然微不足道，但是我们将它们从循环中挪了出来。MESSAGE 也设置成了常量。这是因为 Java 总是喜欢到处创建 String 对象。如果不控制好，这些字符串将消耗大量的内存。别不以为然，当你过多的消耗内存，将转而影响整体性能，尤其当垃圾收集器被频繁调用的时候。字符串制造垃圾，而垃圾是糟糕的；而使用字符串常量能缓解这个问题。稍后我们会讲到如何利用 StringBuffer 来完全解决由字符串泛滥带来的内存损耗。stringImage = Image.createImage( font.stringWidth( msMessage ),
font.getBaselinePosition() );
imageGraphics = stringImage.getGraphics();
imageGraphics.setFont( font );
Graphics 对象提出来，另一点很爽的地方在于，我们只需要对字体设置一次，然后就可以完全不再去管它；而不用每次循环的时候都来设置它。不过仍然每次都需要调用 fillRect() 方法来擦去图像上的内容。编码狂人们可能会想要这样做，从同一个 Image 创建两个 Graphics 对象，然后将其中一个的颜色预设为 COLOR_BG 用来调用 fillRect()，另一个设置为 COLOR_FG 用来调用 drawString()。很遗憾，J2ME 中，对同一个 Image 多次调用 getGraphics() 方法的行为，定义的并不好，不同的平台会有不同的结果，因此你优化的结果可能对 Motorola 有效但 NOKIA 却不行。当无法确定的时候，不要做任何无根据假设。paint() 方法的途径。动动我们的脑子我们会意识到，仅当 frameTime 的值发生改变的时候我们才需要重绘该字符串。这也就是我们引入新的变量 oldFrameTime 的原因。以下是新的方法： public void paint(Graphics g) {
g.setColor( COLOR_BG );
g.fillRect( 0, 0, getWidth(), getHeight() );
if ( frameTime != oldFrameTime ) {
msMessage = frameTime + MESSAGE;
imageGraphics.setColor( COLOR_BG );
imageGraphics.fillRect( 0, 0, stringImage.getWidth(),
stringImage.getHeight() );
imageGraphics.setColor( COLOR_FG );
imageGraphics.drawString( msMessage, 0, 0, textAnchor );
}
for ( int i = 0 ; i < DRAW_COUNT ; i ++ ) {
g.drawImage( stringImage, getRandom( getWidth() ),
getRandom( getHeight() ), graphicAnchor );
}
oldFrameTime = frameTime;
}
OCanvas 的 paint() 方法所花费的时间占总时间的百分率已经下降到了 41.02%。相比以前由 drawString() 和 fillRect() 引发的 101 次 paint() 来讲，现在只调用了 69 次。这是相当不错的改进，而且可以继续的空间不多了，这也是我们该认真起来的时候。优化总是越来越难。现在我们要刮掉循环中最后一点冗余的代码。我们可能只能再削减非常少的百分率，但是如果幸运的话，还是可以得到一些显著的改进。getHeight() 和 getWidth() 方法，我们可以只调用它们一次，然后把结果缓存在循环之外。然后我们要停止使用 String，而用 StringBuffer 来手动地处理。我们可以通过调用 Graphics.setClip() 限制绘制区域来减少 drawImage() 调用所花费地时间。最后，我们要避免在循环中调用 java.util.Random.nextInt()。private static final String MESSAGE = "ms per frame:";
private int iw, ih, dw, dh;
private StringBuffer stringBuffer;
private int messageLength;
private int stringLength;
private char[] stringChars;
private static final int RANDOMCOUNT = 256;
private int[] randomNumbersX = new int[RANDOMCOUNT];
private int[] randomNumbersY = new int[RANDOMCOUNT];
private int ri;
iw = stringImage.getWidth();
ih = stringImage.getHeight();
dw = getWidth();
dh = getHeight();
for ( int i = 0 ; i < RANDOMCOUNT ; i++ ) {
randomNumbersX[i] = getRandom( dw );
randomNumbersY[i] = getRandom( dh );
}
ri = 0;
stringBuffer = new StringBuffer( MESSAGE+"000" );
messageLength = MESSAGE.length();
stringLength = stringBuffer.length();
stringChars = new char[stringLength];
stringBuffer.getChars( 0, stringLength, stringChars, 0 );
Display 和图像的区域，还缓存了对 getRandom() 方法的 512 次调用，并用 StringBuffer 取代了 msMessage 字符串。当然，最大的目标还是 paint() 方法：public void paint(Graphics g) {
g.setColor( COLOR_BG );
g.fillRect( 0, 0, dw, dh );
if ( frameTime != oldFrameTime ) {
stringBuffer.delete( messageLength, stringLength );
stringBuffer.append( (int)frameTime );
stringLength = stringBuffer.length();
stringBuffer.getChars( messageLength,
stringLength,
stringChars,
messageLength );
iw = font.charsWidth( stringChars, 0, stringLength );
imageGraphics.setColor( COLOR_BG );
imageGraphics.fillRect( 0, 0, iw, ih );
imageGraphics.setColor( COLOR_FG );
imageGraphics.drawChars( stringChars, 0,
stringLength, 0, 0, textAnchor );
}
for ( int i = 0 ; i < DRAW_COUNT ; i ++ ) {
g.setClip( randomNumbersX[ri], randomNumbersY[ri], iw, ih );
g.drawImage( stringImage, randomNumbersX[ri],
randomNumbersY[ri], textAnchor );
ri = (ri+1) % RANDOMCOUNT;
}
oldFrameTime = frameTime;
}
StringBuffer 来绘制消息的字符。在 StringBuffer 结尾添加字符，比在开头插入要容易，因此我们调整了显示文字，frameTime 放到了消息的结尾，即“ms per frame:120”。这样我们每次只是更改 frameTime 的几个字符，而消息的文字则原封不动。像这样使用 StringBuffer，能够让系统不至于在每次循环的时候都要创建和销毁 String 对象。这是额外的工作，但是值得。注意我把 frame 强转成了 int，因为我发现使用 append(long) 会导致内存泄漏。我不知道为什么，不过这是很好的一个例子说明为什么在使用工具的时候要用眼睛盯好。font.charsWidth() 来计算消息图像的宽度，这样我们能够尽量少做绘制的工作。我们使用了一个等宽的字体，因此图像“ms per frame:1”会比“ms per frame:888”小，而我们又在使用 Graphics.setClip()，因此我们不需要绘制多余的部分。这也意味着我们需要绘制一个足够大的矩形来清空我们需要的区域。当然，我们希望在绘图上节省的时间比因调用 font.charsWidth() 而多花的时间要多。font.getBaselinePosition() 实现的错误返回值的阻碍，因为本来应该返回和 font.getHeight() 相同的值。唉～！textAnchor 来绘制图像和字符串，这样 setClip() 才能正确工作。paint() 方法比没有做这些改变时，多花大约 7% 的时间。这可能得怪对 font.charsWidth() 的调用，因为它占用了 4.6%。（这并不太多，但是应该可以被减少。注意我们每次都在取得 MESSAGE 字符串的宽度，实际上我们可以在循环体之前就轻易的计算出，然后再加上 frameTime 的宽度。）同时，对 setClip() 的调用标示的是 0.85%，而花在 drawImage 上的时间看起来增加的比较显著（从 27.58% 到 33.94%）。setClip() 或者 charsWidth()，结果为 37130ms，而两个都调用得话，结果是 36540。在我耐心能够坚持的情况下，我把这个测试运行了很多遍，而结果是相同的。这也再次强调了不同的运行环境会有不同的结果。当你到了某一点无法确定是否做了改进的时候，你可能被迫在硬件上继续所有的测试，这需要对 JAR 文件进行很多安装和卸载工作。work() 方法实施高端和低端优化的时候了。先让我们来复习一下这个方法：public synchronized int work( int[] n ) {
r = 0;
for ( int j = 0 ; j < DIVISOR_COUNT ; j++ ) {
for ( int i = 0 ; i < n.length ; i++ ) {
divisor = getDivisor(j);
r += workMore( n, i, divisor );
}
}
return r;
}
work() 方法中外层的循环计算我们的除数(divisor)，然后调用 workMore() 来实施除法。可能已经发现，这里整件事情都有问题。开始的时候，编程的把对 getDivisor() 的调用放到了内层循环。由于 j 的值在内层循环过程中并不发生改变，因此除数也不发生变化，这完全应该放在内层循环之外。public synchronized int work( int[] n ) {
r = 0;
divisor = 1;
for ( int j = 0 ; j < DIVISOR_COUNT ; j++ ) {
for ( int i = 0 ; i < n.length ; i++ ) {
r += workMore( n, i, divisor );
}
divisor *= 2;
}
return r;
}
run() 方法花费 23.72% 的时间，而我们做这些改进之前，这个值为 38.78%。在陷入低端优化把戏之前，请总是先用头脑来优化。不过，说到这里，还是让我们来看看这些小把戏。
com.sun.kvem.midp.lcdui.EmulEventHandler$EventLoop.run 的方法消耗，这对我们帮助不大。继续向下挖掘一两层具有类似奇怪名称的方法文件夹，你将追踪到大的百分比方法 serviceRepaints()，然后最终到我们的 OCanvas.paint() 方法。另外 30% 的时间被它消耗。这两个方法都存在于游戏的主循环终，这并不奇怪——我们不会花费时间去优化 MIDlet 类中的代码，同时你也不会去为优化游戏主循环之外的代码费心。只优化那些反复运行的部分。paint() 方法上。和非图像处理的部分比起来，图像处理的常规操作会花费非常多的时间。遗憾的是，图像处理的常规操作早已封装在 J2ME API 之下，在这一点上，我们没有多少余地用来改善其性能。我们所能做的是，聪明地决定我们用它们中的哪一个，以及如何使用它们。paint() 方法里面干了些什么。每次循环我们调用了 16 次 Graphics.drawString() 方法用来在屏幕上显示“n ms per frame”。我们并不知道 drawString 方法内部的工作原理，但是我们知道它被用了很多次，于是让我们尝试一下另一种途径。我们可以把字符串直接一次性画到一个 Image 对象中，然后将该 Image 绘制 16 次。public void paint(Graphics g) {
g.setColor( COLOR_BG );
g.fillRect( 0, 0, getWidth(), getHeight() );
Font font = Font.getFont( Font.FACE_PROPORTIONAL,
Font.STYLE_BOLD | Font.STYLE_ITALIC,
Font.SIZE_SMALL );
String msMessage = frameTime + "ms per frame";
Image stringImage =
Image.createImage( font.stringWidth( msMessage ),
font.getBaselinePosition() );
Graphics imageGraphics = stringImage.getGraphics();
imageGraphics.setColor( COLOR_BG );
imageGraphics.fillRect( 0, 0, stringImage.getWidth(),
stringImage.getHeight() );
imageGraphics.setColor( COLOR_FG );
imageGraphics.setFont( font );
imageGraphics.drawString( msMessage, 0, 0,
Graphics.TOP | Graphics.LEFT );
for ( int i = 0 ; i < DRAW_COUNT ; i ++ ) {
g.drawImage( stringImage, getRandom( getWidth() ),
getRandom( getHeight() ),
Graphics.VCENTER | Graphics.HCENTER );
}
}
paint() 方法上花费的时间的百分率变小了一点点。更深入的观察我们会发现 drawString 方法仅被调用了 101 次，而 drawImage() 方法做了大部分的动作，被调用了 1616 次。尽管如此我们还是有成效，程序跑得更快了，因为我们使用的图形调用更快。import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class OptimizeMe extends MIDlet implements CommandListener {
private static final boolean debug = false;
private Display display;
private OCanvas oCanvas;
private Form form;
private StringItem timeItem = new StringItem( "Time: ", "Unknown" );
private StringItem resultItem =
new StringItem( "Result: ", "No results" );
private Command cmdStart = new Command( "Start", Command.SCREEN, 1 );
private Command cmdExit = new Command( "Exit", Command.EXIT, 2 );
public boolean running = true;
public OptimizeMe() {
display = Display.getDisplay(this);
form = new Form( "Optimize" );
form.append( timeItem );
form.append( resultItem );
form.addCommand( cmdStart );
form.addCommand( cmdExit );
form.setCommandListener( this );
oCanvas = new OCanvas( this );
}
public void startApp() throws MIDletStateChangeException {
running = true;
display.setCurrent( form );
}
public void pauseApp() {
running = false;
}
public void exitCanvas(int status) {
debug( "exitCanvas - status = " + status );
switch (status) {
case OCanvas.USER_EXIT:
timeItem.setText( "Aborted" );
resultItem.setText( "Unknown" );
break;
case OCanvas.EXIT_DONE:
timeItem.setText( oCanvas.elapsed+"ms" );
resultItem.setText( String.valueOf( oCanvas.result ) );
break;
}
display.setCurrent( form );
}
public void destroyApp(boolean unconditional)
throws MIDletStateChangeException {
oCanvas = null;
display.setCurrent ( null );
display = null;
}
public void commandAction(Command c, Displayable d) {
if ( c == cmdExit ) {
oCanvas = null;
display.setCurrent ( null );
display = null;
notifyDestroyed();
}
else {
running = true;
display.setCurrent( oCanvas );
oCanvas.start();
}
}
public static final void debug( String s ) {
if (debug) System.out.println( s );
}
}
OCanvas 做了本例中大部分的工作——import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.Random;
public class OCanvas extends Canvas implements Runnable {
public static final int USER_EXIT = 1;
public static final int EXIT_DONE = 2;
public static final int LOOP_COUNT = 100;
public static final int DRAW_COUNT = 16;
public static final int NUMBER_COUNT = 64;
public static final int DIVISOR_COUNT = 8;
public static final int WAIT_TIME = 50;
public static final int COLOR_BG = 0x00FFFFFF;
public static final int COLOR_FG = 0x00000000;
public long elapsed = 0l;
public int exitStatus;
public int result;
private Thread animationThread;
private OptimizeMe midlet;
private boolean finished;
private long started;
private long frameStarted;
private long frameTime;
private int[] numbers;
private int loopCounter;
private Random random = new Random( System.currentTimeMillis() );
public OCanvas( OptimizeMe _o ) {
midlet = _o;
numbers = new int[ NUMBER_COUNT ];
for ( int i = 0 ; i < numbers.length ; i++ ) {
numbers[i] = i+1;
}
}
public synchronized void start() {
started = frameStarted = System.currentTimeMillis();
loopCounter = result = 0;
finished = false;
exitStatus = EXIT_DONE;
animationThread = new Thread( this );
animationThread.start();
}
public void run() {
Thread currentThread = Thread.currentThread();
try {
while ( animationThread == currentThread && midlet.running
&& !finished ) {
frameTime = System.currentTimeMillis() - frameStarted;
frameStarted = System.currentTimeMillis();
result += work( numbers );
repaint();
synchronized(this) {
wait( WAIT_TIME );
}
loopCounter++;
finished = ( loopCounter > LOOP_COUNT );
}
}
catch ( InterruptedException ie ) {
OptimizeMe.debug( "interrupted" );
}
elapsed = System.currentTimeMillis() - started;
midlet.exitCanvas( exitStatus );
}
public void paint(Graphics g) {
g.setColor( COLOR_BG );
g.fillRect( 0, 0, getWidth(), getHeight() );
g.setColor( COLOR_FG );
g.setFont( Font.getFont( Font.FACE_PROPORTIONAL,
Font.STYLE_BOLD | Font.STYLE_ITALIC, Font.SIZE_SMALL ) );
for ( int i = 0 ; i < DRAW_COUNT ; i ++ ) {
g.drawString( frameTime + " ms per frame",
getRandom( getWidth() ),
getRandom( getHeight() ),
Graphics.TOP | Graphics.HCENTER );
}
}
private int divisor;
private int r;
public synchronized int work( int[] n ) {
r = 0;
for ( int j = 0 ; j < DIVISOR_COUNT ; j++ ) {
for ( int i = 0 ; i < n.length ; i++ ) {
divisor = getDivisor(j);
r += workMore( n, i, divisor );
}
}
return r;
}
private int a;
public synchronized int getDivisor( int n ) {
if ( n == 0 ) return 1;
a = 1;
for ( int i = 0 ; i < n ; i++ ) {
a *= 2;
}
return a;
}
public synchronized int workMore( int[] n, int _i, int _d ) {
return n[_i] * n[_i] / _d + n[_i];
}
public void keyReleased(int keyCode) {
if ( System.currentTimeMillis() - started > 1000l ) {
exitStatus = USER_EXIT;
midlet.running = false;
}
}
private int getRandom( int bound )
{ // return a random, positive integer less than bound
return Math.abs( random.nextInt() % bound );
}
}
LOOP_COUNT = 100)，并且用一个系统时钟来计算整个过程花费了多少时间（毫秒），这样我们就能测量并且改进其性能。时间和结果显示在一个简单的表单中。用“开始”命令来启动测试，按任意键中止循环，用“退出”命令退出程序。run() 方法同样计算出每次循环所花的执行时间。每一帧，OCanvas.paint() 方法都将在屏幕上 16 个位置的其中随机之一显示这个时间的毫秒数。正常情况下你可能会在这个方法中绘制游戏中的元素，这里我们的代码只是对这个过程提供一个合理的模拟。