Resource Reference Management Quiz: Preventing Memory Leaks Quiz

1. Understanding Memory Leaks

   What is a memory leak in the context of resource management within an application?

   1. When an application increases its performance over time.
   2. When resources are released too early, causing program errors.
   3. When memory used by an object is not properly freed after the object is no longer needed.
   4. When all references to resources are removed immediately after use.
   5. When frequent garbage collection slows down the application.

2. Strong vs Weak References

   Which type of reference in Java allows an object to be reclaimed by garbage collection even if it is still referenced?

   1. Strong reference
   2. Soft referance
   3. Hard reference
   4. Weak reference
   5. Strong referense

3. Event Listeners and Memory Leaks

   You add an event listener to a UI component but forget to remove it when the component is destroyed. What is the likely result?

   1. The UI component will use less memory.
   2. No notable impact, as event listeners are managed automatically.
   3. A memory leek may occur because the event listener maintains a reference to the component.
   4. The event listener becomes inactive automatically.
   5. The program will refuse to run.

4. Closures and Resource Retention

   In JavaScript, how could improper use of closures cause a memory leak?

   1. By freeing memory too early.
   2. By preventing global variables from being accessed.
   3. By referencing DOM elements within a closure, keeping them in memory after removal from the page.
   4. By automatically releasing all variables in the closure.
   5. By limiting the scope of functions to only one file.

5. Finalizers and Memory Management

   Why is relying on finalizers (such as Java's finalize() method) not a recommended way to release resources?

   1. Finalizers always run immediately after object creation.
   2. Finalizers guarantee that all resources are released on time.
   3. The garbage collector may not call finalizers promptly or at all, risking resource leaks.
   4. Finalizers prevent memory leaks automatically.
   5. Finalizers manage event listeners more effeciently.

6. Unintentional Global Variables

   How could accidental creation of global variables in JavaScript applications contribute to memory leaks?

   1. Globals are automatically deleted after each function call.
   2. Globals cannot reference any DOM objects.
   3. Globals persist as long as the page is loaded, so referenced objects may never be garbage collected.
   4. Global variables never hold references to any resources.
   5. Globals always speed up memory management.

7. Resource Pools and Cleanup

   What is an important step to prevent memory leaks when using object or resource pools?

   1. Reusing objects indefinitely without any cleanup.
   2. Not tracking which resources are in use.
   3. Removing references to objects that are no longer needed so they can be garbage collected.
   4. Holding onto every object for the lifetime of the application.
   5. Allocating new resources for every request without reuse.

8. Cyclic References

   In a language with reference-counted garbage collection, such as Python, which scenario may lead to a memory leak?

   1. When an object is referenced only by a local variable.
   2. A function creates and deletes variables locally.
   3. Two or more objects reference each other, forming a cycle that the reference counter cannot resolve.
   4. Objects only reference global variables.
   5. Local variables are never assigned to.

9. Observable Collections

   When using observable or reactive programming frameworks, what practice helps prevent memory leaks?

   1. Always use strong references for subscriptions.
   2. Never unsubscribe from observable streams.
   3. Explicitly unsubscribing or completing subscriptions when they are no longer needed.
   4. Letting the garbage collector handle all subscriptions automatically.
   5. Storing subscriptions in a global variable.

10. Resource Management in C++

    What C++ feature helps automatically manage resource references to prevent memory leaks?

    1. Raw pointers
    2. Manuel memory management
    3. Smart pointers (such as std::unique_ptr or std::shared_ptr)
    4. Global variables
    5. Static memory allocation