LibGdx RAM使用率持续增加

Question

I wrote these 3 classes to test them on android. If I just press Menu button and hide the app, then open it again, then hide and reopen it again and again ram usage increases every time I hide the app.

The same problem occurs if I just switch between classes inside the app, app uses more and more ram.

I was looking for a solution of this problem here and I saw tutorials on yotube, but I have not found it. I don't understand what can be wrong here.

Can someone explain what am I doing wrong?

public class MyEF extends Game {

    @Override
    public void create() {

        setScreen(new TestScreen1(this));
    }

    @Override
    public void dispose() {
        super.dispose();
    }

    @Override
    public void render() {
        super.render();
    }

    @Override
    public void resize(int width, int height) {
        super.resize(width, height);
    }

    @Override
    public void pause() {
        super.pause();
    }

    @Override
    public void resume() {
        super.resume();
    }

}

// TEST1
public class TestScreen1 implements Screen {

    private MyEF game;

    public TestScreen1(MyEF game) {
        this.game = game;
    }

    @Override
    public void render(float delta) {
        Gdx.gl.glClearColor(0, 0, 0, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        if(Gdx.input.justTouched()){
            game.setScreen(new TestScreen2(game));
            dispose();
            System.out.println("TOUCHED ");
        }

    }

    @Override
    public void show() {
    }

    @Override
    public void dispose() {
        game.dispose();
    }

    @Override
    public void hide() {
    }
    @Override
    public void pause() {
    }
    @Override
    public void resume() {
    }
    @Override
    public void resize(int width, int height) {
    }
}

// TEST2
public class TestScreen2 implements Screen {

    private MyEF game;

    public TestScreen2(MyEF game) {
        this.game = game;
    }

    @Override
    public void render(float delta) {
        Gdx.gl.glClearColor(1, 1, 1, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        if(Gdx.input.justTouched()){
            game.setScreen(new TestScreen1(game));
            dispose();
            System.out.println("TOUCHED ");
        }

    }

    @Override
    public void show() {
    }

    @Override
    public void dispose() {
        game.dispose();
    }

    @Override
    public void hide() {
    }
    @Override
    public void pause() {
    }
    @Override
    public void resume() {
    }
    @Override
    public void resize(int width, int height) {
    }
}

Answer 1

I'd not have any static Screens because of this. "Resetting" screens will introduce bugs and not very well maintainable code. It is easier in many cases to just create a new "clean" screen.

Also you are describing an effect here. Not a problem . Yes the memory usage increases. But is it a problem? No! Why not? Because the user won't send the app to the background and restart it 1000 times in a row. And even if he does, the memory usage will not grow endlessly. It keeps growing because the amount of memory which gets added is so small that the JVM does not even invoke the garbage collector.

After enough iterations of resuming the app, the garbage collector will eventually kick in and clean up all your unused screens.

In general you should not change your architecture now, based on this behaviour. As a rule of thumb you can always instantiate new objects, for example when switching screens, or when doing things only once. The user will not be bothered if the garbage collector kicks in in a loading screen, or when the game just started. You should only be concerned when doing it in the render() method, because then the garbage collector might clean up while the actual gameplay and may cause lags.

Answer 2

Stuntmania is correct. Creating new objects = increased RAM usage, especially when you do it during the render() method. In game development in general, and LibGDX in particular, you should always question your usage of the new keyword. Make things static wherever possible.

Specifically, your main game class should do something like this:

public class MyEF extends Game {
    public static TestScreen1 myScreen1;
    public static TestScreen2 myScreen2;

    @Override
    public static void create() {
        myScreen1 = new TestScreen1(this);
        myScreen2 = new TestScreen2(this);
        setScreen(myScreen1);
    }

    (...)
}

Then, in your render() method for each of the screens, you would simply call game.setScreen(myScreen2) . This way, you are no longer creating new objects during each render cycle.