Java: Why is this List lagging out my game “Out of Memory”

Question

Hello I'm trying to add a tail behind player just like the snake game. But for some reason this keeps lagging out my game and running it out of memory. Why is this happening and how do I fix this?

I create the list like this:

List<Snake> snake = new CopyOnWriteArrayList<Snake>();

This is where I create new objects and remove them in a forloop:

public void snake() {
    snake.add(new Snake(ball.getX(), ball.getY()));
    currentTime++;
    for(Snake currentSnake: snake) {
        if(currentSnake.creationDate < SnakeLength){
            currentSnake.Update();
        } else {
            Gdx.app.log("SnakeLength" + SnakeLength, "CreationDate" + currentSnake.creationDate);
            snake.remove(currentSnake);
        }
    }
}

This is how my snake class looks like:

public class Snake
{
    float width = Gdx.graphics.getWidth();
    float height = Gdx.graphics.getHeight();
    float screenwidth = width/270;
    float screenheight = height/480;

    public float x;
    public float y;
    public int creationDate;
    ShapeRenderer shapeRenderer;
    SpriteBatch batch;

    public boolean active = false;

    public Snake(float x, float y) {
        shapeRenderer = new ShapeRenderer();
        batch = new SpriteBatch();
        this.x = x;
        this.y = y;
    }

    public void Update() {
        batch.begin();
        shapeRenderer.begin(ShapeType.Filled);
        shapeRenderer.setColor(new Color(1, 1, 1, 0.2f));
        shapeRenderer.circle(x + 8*screenwidth, y + 8*screenheight, 6*screenheight);
        shapeRenderer.end();
        batch.end();
        creationDate++;
    }
}

Answer 1

As stated by javadoc CopyOnWriteArrayList :

A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.

So it's costly operation and this class is well designed for concurrent reads with a small modifications rate. It looks like it's not your case.

If you choosed this class to resolve an issue concerning reading a List while modifying it please consider using Iterators with ArrayList which are designed for that usage :

synchronized(snake) { // Protect the snake list against concurrent access. Do it whenever you access the snake list
  for(Iterator<Snake> it = snake.iterator();; it.hasNext()) {
    Snake currentSnake = it.next();
    if(currentSnake.creationDate < SnakeLength) {
        currentSnake.Update();
    } else {
        Gdx.app.log("SnakeLength" + SnakeLength, "CreationDate" + currentSnake.creationDate);
        it.remove();
    }
  }
}

Beware that ArrayList is not protected against concurrent access. If multiple threads are able to read and write to your list you have to protect it with synchronization blocks.

But reading your code I guess a design with a PriorityQueue seems to be more appropriate.

Answer 2

I basically think you get java.util.ConcurrentModificationException exception because you are trying to remove elements (Snakes) while iterating over your List as @Dragondraikk mentioned.

This is not a good reason to use CopyOnWriteArrayList as you can read for example in enter link description here where it explains a bit the usefulness of CopyOnWriteArrayList. Basically CopyOnWriteArrayList is useful if

you mostly need to iterate the ArrayList and don't modify it too often

which you don't.

Why don't you just modify the List you have after having retrieved an element. If you are not satisfied with this behavior, i.e. you don't have a constant number of elements (I guess you don't) try to update them in a separate loop than removing/adding them.

Answer 3

You can't remove an item from a list while you are iterating through it. You need to remove snakes that need removing before updating the rest.

I would suggest:

snakes.removeIf(snake -> snake.createDate > snakeLength);
snakes.stream().forEach(Snake::Update);

Answer 4

to answer the OPs question:

You are going OOM because you are using the CopyOnWriteArrayList which, and I quote the official docs is

A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array. (Emphasis added)