Empty an ArrayList or just create a new one and let the old one be garbage collected? [duplicate]

by

The advantage of recycling an ArrayList (e.g. by calling clear) is that you avoid the overhead of allocating a new one, and the cost of growing it … if you didn’t provide a good initialCapacity hint.

The disadvantages of recycling an ArrayList include the following:

  • The clear() method has to assign null to each (used) slot in the ArrayLists backing array.

  • The clear() does not resize the backing array to release memory. So if you repeatedly fill and clear a list, it will end up (permanently) using enough memory to represent the largest list that it encounters. In other word, you have increased the memory footprint. You can combat that by calling trimToSize(), but that creates a garbage object, etcetera1.

  • There are locality and cross-generational issues that could affect performance. When you repeatedly recycle an ArrayList, the object and its backing array are likely to be tenured. That means that:

    • The list objects and the objects representing list elements are likely to be in different areas of the heap, potentially increasing TLB misses and page traffic, especially at GC time.

    • Assignment of (young generation) references into the (tenured) list’s backing array are likely to incur write barrier overheads … depending on the GC implementation.

It is not possible to accurately model the performance trade-offs for a real-life application. There are just too many variables. However, the “received wisdom” is that recycling is NOT normally a good idea if you have plenty of memory2 and a half-decent garbage collector.

It is also worth noting that a modern JVM can allocate objects very efficiently. It merely needs to update to the heap’s “free” pointer and write 2 or 3 object header words. The zeroing of memory is done by the GC … and besides the work in doing that is roughly equivalent to the work that clear() does to null out references in the list that is being recycled.

1 – It would be better for performance to create a new ArrayList than to call clear() followed by trimToSize(…). With the latter you get both the garbage collection overheads AND the overheads of superfluous nulling.

2 – A copying collector is more efficient if the proportion of garbage objects to non-garbage objects is high. If you analyse the way that this kind of collector works, the costs are almost all incurred in finding and copying reachable objects. The only thing that needs to be done to garbage objects is to block-zero-write the evacuated “from” space ready for allocation of new objects.

My advice would be NOT to recycle ArrayList objects unless you have a demonstrable need to minimize the (garbage) object creation rate; e.g. because it is the only option you have for reducing (harmful) GC pauses.

All things being equal, on a modern Hotspot JVM my understanding is that you will get best performance by doing the following:

  • Allocating new ArrayList objects rather than recycling.
  • Use accurate initialSize hints when you allocate the list objects. It is better to slightly overestimate than slightly underestimate.

More Related Contents:

  1. When to use LinkedList over ArrayList in Java?
  2. Initialization of an ArrayList in one line
  3. How do I remove repeated elements from ArrayList?
  4. Sorting an ArrayList of objects using a custom sorting order
  5. Converting ‘ArrayList to ‘String[]’ in Java
  6. How to sort a List/ArrayList?
  7. How to count the number of occurrences of an element in a List
  8. How to find an object in an ArrayList by property
  9. How to sort an ArrayList in Java [duplicate]
  10. Which Java Collection should I use?
  11. How to randomize two ArrayLists in the same fashion?
  12. How do I make my ArrayList Thread-Safe? Another approach to problem in Java?
  13. How to sort an ArrayList using multiple sorting criteria?
  14. Best way to create a hashmap of arraylist
  15. Add multiple items to an already initialized arraylist in Java
  16. How to remove element from ArrayList by checking its value?
  17. ArrayList filter [duplicate]
  18. ArrayList Vs LinkedList
  19. ArrayList: how does the size increase?
  20. What is the Simplest Way to Reverse an ArrayList?
  21. Java Collections and Garbage Collector
  22. ArrayList vs LinkedList from memory allocation perspective
  23. Vector vs Collections.synchronizedList(ArrayList)
  24. Does the capacity of ArrayList decrease when we remove elements?
  25. How to remove common values from two array lists
  26. How to sort Arraylist of objects
  27. Map.clear() vs new Map : Which one will be better? [duplicate]
  28. Java – generate Random range of specific numbers without duplication of those numbers – how to?
  29. Searching in a ArrayList with custom objects for certain strings
  30. Default garbage collector for Java 8

Leave a Comment