Which pattern reduces runtime allocations by reusing objects instead of creating and destroying them frequently?

Which pattern reduces runtime allocations by reusing objects instead of creating and destroying them frequently?

• A. Singleton
• B. Factory
• C. Observer
• D. Object pools

Answer: (D)

The pattern that reduces runtime allocations by reusing objects instead of creating and destroying them frequently is object pools. The idea is to keep a ready-made set of objects around and hand them out as needed, then return them to the pool when you’re finished so they can be reset and reused later. This approach cuts allocations because you’re not repeatedly allocating new objects on demand or triggering garbage collection for many short-lived instances. Instead, you pay the cost of creating a fixed pool up front or as needed, and the per-use cost becomes a quick reset and reassign, which is much cheaper in tight loops like game loops or real-time simulations. In practice, when you need an object, you grab one from the pool, reinitialize its state, use it, and then return it to the pool instead of letting it go out of scope and be garbage collected. That reuse is what minimizes runtime allocations and helps keep performance smooth. Other patterns have different goals. A singleton ensures one globally accessible instance, not a reuse strategy for many objects. A factory centralizes creation logic but doesn’t inherently avoid allocations. An observer manages event notification relationships and has nothing to do with reusing object memory.

The pattern that reduces runtime allocations by reusing objects instead of creating and destroying them frequently is object pools. The idea is to keep a ready-made set of objects around and hand them out as needed, then return them to the pool when you’re finished so they can be reset and reused later.

This approach cuts allocations because you’re not repeatedly allocating new objects on demand or triggering garbage collection for many short-lived instances. Instead, you pay the cost of creating a fixed pool up front or as needed, and the per-use cost becomes a quick reset and reassign, which is much cheaper in tight loops like game loops or real-time simulations.

In practice, when you need an object, you grab one from the pool, reinitialize its state, use it, and then return it to the pool instead of letting it go out of scope and be garbage collected. That reuse is what minimizes runtime allocations and helps keep performance smooth.

Other patterns have different goals. A singleton ensures one globally accessible instance, not a reuse strategy for many objects. A factory centralizes creation logic but doesn’t inherently avoid allocations. An observer manages event notification relationships and has nothing to do with reusing object memory.