Module 9: Memory and Resource Management

Overview Memory Management Basics Non-Memory Resource Management Implicit Resource Management Explicit Resource Management Optimizing Garbage Collection

Memory Management Basics Developer Backgrounds Manual vs. Automatic Memory Management Memory Management of .NET Framework Types Simple Garbage Collection

Developer Backgrounds COM Manually implement reference counting and handle circular references C++ Manually use the new operator and delete operator Visual Basic Accustomed to automatic memory management

Manual vs. Automatic Memory Management Manual Memory Management Programmer manages memory Common Problems Failure to release memory Invalid references to freed memory .NET Runtime Provides Automatic Memory Management Eases programming task Eliminates a potential source of bugs

Memory Management of .NET Framework Types Instances of Value Types Use Stack Memory Allocation and deallocation are automatic and safe Managed Objects Are Reference Types and Use Heap Memory Created by calls to the new operator Freed by garbage collection

Simple Garbage Collection Simple Garbage Collection Algorithm Wait until managed code threads are in a safe state Build a graph of all reachable objects Move reachable objects to compact heap - Unreachable objects’ memory is reclaimed Update references to all moved objects Reference Cycles Are Handled Automatically

Multimedia: Simple Garbage Collection

Non-Memory Resource Management Implicit Resource Management Explicit Resource Management

Implicit Resource Management Finalization Garbage Collection with Finalization Finalization Guidelines Controlling Garbage Collection

Finalization Finalize Code Called by Garbage Collection In C#, the Finalize Code Is Provided by a Destructor Use C# Destructor to Implicitly Close a FileStream class Foo { private System.IO.FileStream fs; //... public Foo() { fs = new System.IO.FileStream( “bar”, FileMode.CreateNew); } ~Foo() { fs.Close(); }

Garbage Collection with Finalization Runtime Maintains a List of Objects That Require Finalization Finalization queue Garbage Collection Process Invoked Unreachable Objects Requiring Finalization References added to freachable queue Objects are now reachable and not garbage Move Reachable Objects to Compact the Heap Unreachable objects' memory is reclaimed Update References to All Moved Objects

Garbage Collection with Finalization (Continued) Finalize Thread Runs Executes freachable objects' Finalize methods References removed from freachable queue Unless resurrected, objects are now garbage May be reclaimed next time garbage collection occurs

Multimedia: Garbage Collection

Finalization Guidelines Avoid Finalization and Destructors If Possible Performance costs Complexity Delay of memory resource release If You Require Finalization, Finalize Code Should: Avoid calling other objects Avoid making assumptions about thread ID Classes with Finalization Should: Avoid making references to other objects

Controlling Garbage Collection To Force Garbage Collection To Suspend Calling Thread Until Thread’s Queue of Finalizers Is Empty To Allow a Finalized Resurrected Object to Have Its Finalizer Called Again To Request the System Not to Call the Finalizer Method void System.GC.Collect(); void System.GC.WaitForPendingFinalizers(); void System.GC.ReRegisterForFinalize(object obj); void System.GC.SuppressFinalize(object obj);

Demonstration: Finalization

Explicit Resource Management The IDisposable Interface and the Dispose Method Temporary Resource Usage Design Pattern

The IDisposable Interface and the Dispose Method Inherit from the IDisposable Interface Implement the Dispose Method Follow the .NET Framework SDK’s Design Pattern class ResourceWrapper : IDisposable { // see code example for details }

Demonstration: The IDisposable Interface

Temporary Resource Usage Design Pattern Temporary Resource Use Allocate a resource, use it, and dispose of it Try and Finally Using Statement void DoSomething() { Resource r = new Resource(...); try { r.Foo(); } finally { if (r != null) ((IDisposable)r).Dispose(); } } using (Resource r1 = new Resource()) { r1.Foo(); }

Optimizing Garbage Collection Weak References Generations Additional Performance Features

Weak References A Weak Reference Allows an Object to Be Collected If Memory Is Low Object obj = new Object(); // create strong reference WeakReference wr = new WeakReference(obj); obj = null; // remove strong reference // ... obj = (Object) wr.Target; if (obj != null) {//garbage collection hasn’t occurred } else {// object was collected, reference is null //...

Demonstration: Weak References

Generations To Force Garbage Collection of Generation 0 Through a Specified Generation: To Determine the Generation of an Object: To Return the Maximum Number of Generations That the System Currently Supports: void System.GC.Collect(int Generation); Int32 System.GC.GetGeneration(Object obj); Int32 System.GC.MaxGeneration;

Demonstration: Generations

Additional Performance Features Performance Monitoring Large Object Heap Multiprocessor Support Unsafe Code

Lab 9: Memory and Resource Management

Review Memory Management Basics Non-Memory Resource Management Implicit Resource Management Explicit Resource Management Optimizing Garbage Collection