有没有办法安全地传递线程作为参数?

时间:2012-08-04 10:22:44

标签: java android multithreading thread-safety

我有一个Android游戏的开始。它有一个跟踪f​​ps值的GameLoop(线程)类和一个GameView(surfaceview),用于实例化GameLoop对象并设置它运行等等。 现在我有一个单独的FpsText对象,它知道如何将自己绘制到屏幕上,但要更新我需要执行fpsText.setText(gameloop.getFps());

之类的操作

如果我在GameView课程中这样做,这不是问题,但我想尝试拥有一个FpsText对象,可以自行更新。我对线程没有任何其他经验,我认为它可能适得其反,但我尝试将fpsText gameloop引用作为参数传递。不出所料我每次运行应用程序时都会得到不同的不需要的结果,所以我想知道你认为处理这种情况的最佳方法是什么?

作为在fpsText中更新GameView的替代方法,我总是可以将gameloop类中的fps值公开,但我知道这是不好的做法!听起来不是很好的解决方案,或许还有更好的方法吗?

这里的参考是我的游戏循环,RedOrav建议的第二个变化是:

package biz.hireholly.engine;

import android.graphics.Canvas;
import android.util.Log;
import android.view.SurfaceHolder;
import biz.hireholly.gameplay.FpsText;

import java.util.ArrayList;


/**
 * The GameLoop is a thread that will ensure updating and drawing is done at set intervals.
 * The thread will sleep when it has updated/rendered quicker than needed to reach the desired fps.
 * The loop is designed to skip drawing if the update/draw cycle is taking to long, up to a MAX_FRAME_SKIPS.
 * The Canvas object is created and managed to some extent in the game loop,
 * this is so that we can prevent multiple objects trying to draw to it simultaneously.
 * Note that the gameloop has a reference to the gameview and vice versa.
 */

public class GameLoop extends Thread {

    private static final String TAG = GameLoop.class.getSimpleName();
    //desired frames per second
    private final static int MAX_FPS = 30;
    //maximum number of drawn frames to be skipped if drawing took too long last cycle
    private final static int MAX_FRAME_SKIPS = 5;
    //ideal time taken to update & draw
    private final static int CYCLE_PERIOD = 1000 / MAX_FPS;

    private SurfaceHolder surfaceHolder;
    //the gameview actually handles inputs and draws to the surface
    private GameView gameview;

    private boolean running;
    private long beginTime = 0; // time when cycle began
    private long timeDifference = 0; // time it took for the cycle to execute
    private int sleepTime = 0; // milliseconds to sleep (<0 if drawing behind schedule) 
    private int framesSkipped = 0; // number of render frames skipped

    private double lastFps = 0; //The last FPS tracked, the number displayed onscreen
    private ArrayList<Double> fpsStore = new ArrayList<Double>(); //For the previous fps values
    private long lastTimeFpsCalculated = System.currentTimeMillis(); //used in trackFps
    FpsText fpsText;

    public GameLoop(SurfaceHolder surfaceHolder, GameView gameview, FpsText fpsText) {
        super();
        this.surfaceHolder = surfaceHolder;
        this.gameview = gameview;
        this.fpsText = fpsText;
    }

    public void setRunning(boolean running) {
        this.running = running;     
    }
    @Override
    public void run(){

        Canvas c;

        while (running) {
            c = null;
            //try locking canvas, so only we can edit pixels on surface
            try{
                c = this.surfaceHolder.lockCanvas();
                //sync so nothing else can modify while were using it
                synchronized (surfaceHolder){ 

                    beginTime = System.currentTimeMillis();
                    framesSkipped = 0; //reset frame skips

                    this.gameview.update();
                    this.gameview.draw(c);

                    //calculate how long cycle took
                    timeDifference = System.currentTimeMillis() - beginTime;
                    //good time to trackFps?
                    trackFps();

                    //calculate potential sleep time
                    sleepTime = (int)(CYCLE_PERIOD - timeDifference);

                    //sleep for remaining cycle
                    if (sleepTime >0){
                        try{
                            Thread.sleep(sleepTime); //saves battery! :)
                        } catch (InterruptedException e){}
                    }
                    //if sleepTime negative then we're running behind
                    while (sleepTime < 0 && framesSkipped < MAX_FRAME_SKIPS){
                        //update without rendering to catch up
                        this.gameview.update();
                        //skip as many frame renders as needed to get back into
                        //positive sleepTime and continue as normal
                        sleepTime += CYCLE_PERIOD;
                        framesSkipped++;
                    }

                }

            } finally{
                //finally executes regardless of exception, 
                //so surface is not left in an inconsistent state
                if (c != null){
                    surfaceHolder.unlockCanvasAndPost(c);
                }
            }
        }

    }

    /* Calculates the average fps every second */
    private void trackFps(){
        synchronized(fpsStore){
            long currentTime = System.currentTimeMillis();

            if(timeDifference != 0){
                fpsStore.add((double)(1000 / timeDifference));
            }
            //If a second has past since last time average was calculated,
            // it's time to calculate a new average fps to display
            if ((currentTime - 1000) > lastTimeFpsCalculated){


                for (Double fps : fpsStore){
                lastFps += fps;
                }

                lastFps /= fpsStore.size();

                synchronized(fpsText){ //update the Drawable FpsText object
                fpsText.setText(String.valueOf((int)lastFps));
                }

                lastTimeFpsCalculated = System.currentTimeMillis();

                //Log.d("trackFPS()", " fpsStore.size() = "+fpsStore.size()+"\t"+fpsStore.toString());
                fpsStore.clear();


            }
        }
    }

}

1 个答案:

答案 0 :(得分:1)

你有什么不想要的结果?将fps变量公开并设置getfps()与获取fps值完全相同,并且修改GameView中的fps值永远不会有任何意义。

我怀疑你在GameLoop中所做的是在几秒钟之间修改你的fps变量,即获得你的GameView可能也正在阅读的中间值。我建议仅每秒修改一次fps,并保持时间变量,以便进行计算。假设你开始时有0 fps。 GameLoop进行计算,一旦经过一秒钟,你已经收集了它处理的帧数和时间(1秒)。在此之前,无论GameLoop在做什么,GameView总是读取0。在那之后,假设你完成了60 fps,fps变量被修改,并且不受影响直到下一秒。因此,对于接下来的第二步,即使GameView对变量进行了更多的读取,它也总是会得到60。

// Inside GameLoop

private int fps; // Variable you're going to read
private int frameCount; // Keeps track or frames processed
private long lastUpdated;

while(running) {

   if(System.currentTimeMillis() - lastUpdated > 1000) { // 1 second elapsed
      fps = frameCount;
      frameCount = 0;
   }
   frameCount++;
}

public int getFps() {
   return fps;
}

另一种方法是将对fpsText的引用传递给GameLoop,GameLoop仅在每秒传递后修改它。这样,您的渲染线程只需要担心渲染,而GameLoop则需要关注每秒帧数。但请记住,您可能会遇到竞争条件(您在渲染方法中间的GameLoop中使用setText()),您不必担心其他方式。在渲染时和修改它时将fpsText对象包含在同步括号中应该可以帮到你。

如果有帮助,请告诉我们!