Memory management in mobile devices

Basic Concepts of Memory Management

Mobile devices have limited memory resources, and efficient memory management directly impacts application performance and user experience. Memory management involves three core processes: allocation, usage, and release. Developers need to pay attention to issues such as memory leaks and over-allocation. Android and iOS systems employ different memory management mechanisms, but their core goal is the same: to maximize available memory resources.

Common Types of Memory Issues

Memory leaks are the most typical issue, occurring when objects are no longer needed but are not released. For example, an Activity being referenced by a static variable:

// Android memory leak example
public class LeakActivity extends Activity {
    private static Context sContext;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        sContext = this; // Incorrectly holding an Activity reference
    }
}

Memory churn refers to the frequent creation and destruction of objects, causing the garbage collector (GC) to trigger repeatedly. A typical scenario is creating temporary objects continuously while scrolling through a list:

// Memory churn example
recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
    override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
        val tempArray = FloatArray(1000) // Creates a new array on every scroll
        // Processing logic...
    }
})

Android Memory Management Mechanism

Android uses a generational garbage collection mechanism, primarily divided into:

1. Young Generation: Stores newly created objects, with frequent Minor GC occurrences.
2. Old Generation: Stores long-lived objects, with Major GC being more time-consuming.
3. Permanent Generation: Stores class and method metadata (gradually being replaced by Metaspace).

Key optimization points include:

• Avoid creating objects in high-frequency callbacks like onDraw().
• Use object pools to reuse frequently created objects.
• Implement pagination for large data structures.

// Object pool example
public class BitmapPool {
    private static final int MAX_SIZE = 10;
    private static LinkedList<Bitmap> pool = new LinkedList<>();

    public static Bitmap getBitmap(int width, int height) {
        if (!pool.isEmpty()) {
            return pool.removeFirst();
        }
        return Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
    }

    public static void recycle(Bitmap bitmap) {
        if (pool.size() < MAX_SIZE) {
            pool.addLast(bitmap);
        } else {
            bitmap.recycle();
        }
    }
}

iOS Memory Management Mechanism

iOS uses Automatic Reference Counting (ARC) for memory management. Key points include:

1. Strong References: The default reference type, increases the reference count.
2. Weak References: Does not increase the count; automatically set to nil when the object is released.
3. Unowned References: Similar to weak but does not automatically set to nil; requires ensuring the lifecycle.

Typical circular reference scenario:

class ViewController: UIViewController {
    var closure: (() -> Void)?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Circular reference example
        closure = {
            self.doSomething() // closure strongly holds self
        }
    }
    
    func doSomething() { /*...*/ }
}

Solution using capture lists:

closure = { [weak self] in
    self?.doSomething()
}

Memory Analysis Tools

Android Profiler provides real-time memory monitoring:

1. View Java heap memory allocations.
2. Track object allocation stacks.
3. Capture memory dumps (hprof files).

Xcode Instruments core features:

• Allocations: Track detailed memory allocations.
• Leaks: Detect memory leaks.
• VM Tracker: Analyze virtual memory usage.

Practical recommendations:

• Test memory usage on low-end devices.
• Monitor the onTrimMemory() callback to handle low-memory situations.
• Use tools like MAT or LeakCanary for in-depth analysis.

Image Memory Optimization Strategies

Bitmaps are a common source of memory consumption. Android recommendations:

1. Use appropriate inSampleSize to load scaled-down images.
2. Choose lower-precision formats like RGB_565.
3. Recycle unused Bitmaps promptly.

// Image loading optimization example
public static Bitmap decodeSampledBitmap(Resources res, int resId, 
    int reqWidth, int reqHeight) {
    
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeResource(res, resId, options);
    
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
    options.inPreferredConfig = Bitmap.Config.RGB_565;
    options.inJustDecodeBounds = false;
    
    return BitmapFactory.decodeResource(res, resId, options);
}

iOS recommendations:

• Use UIGraphicsBeginImageContextWithOptions instead of older APIs.
• For large images, use imageWithContentsOfFile: for lazy loading.
• Implement didReceiveMemoryWarning to clear caches.

Data Structure Optimization Techniques

Choosing the right data structures can significantly reduce memory usage:

// SparseArray usage example
SparseArray<String> sparseArray = new SparseArray<>();
sparseArray.put(1, "value1"); // Key is a primitive int

// Compared to HashMap
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1, "value1"); // Integer boxing occurs

Multi-Process Memory Management

Android multi-process features to note:

1. Each process has its own memory space.
2. Use android:process to declare a process.
3. Cross-process communication requires data serialization.

Typical use cases:

• Background services running in separate processes.
• WebView isolation to prevent crashes affecting the main process.
• Large memory operations in separate processes.

<!-- AndroidManifest.xml configuration example -->
<service 
    android:name=".MyService"
    android:process=":remote" />

Considerations:

• Static variables are not shared across processes.
• Application is initialized multiple times.
• Process communication overhead must be considered.

Memory Cache Strategy Design

Rational use of caching balances performance and memory:

LRU Cache Implementation Points:

1. Set a maximum memory threshold.
2. Use the Least Recently Used algorithm for eviction.
3. Monitor cache hit rates.

// LruCache example
int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
int cacheSize = maxMemory / 8; // Use 1/8 of available memory

LruCache<String, Bitmap> memoryCache = new LruCache<String, Bitmap>(cacheSize) {
    @Override
    protected int sizeOf(String key, Bitmap value) {
        return value.getByteCount() / 1024; // Return size in KB
    }
};

Multi-Level Cache Architecture:

1. Memory cache: Fast read access.
2. Disk cache: Persistent storage.
3. Network fetch: Ultimate data source.

System Resource Release Timing

Key lifecycle callback handling:

Android Component Release:

@Override
protected void onDestroy() {
    super.onDestroy();
    // Resource release example
    if (mediaPlayer != null) {
        mediaPlayer.release();
        mediaPlayer = null;
    }
    unregisterReceiver(broadcastReceiver);
}

iOS View Controller Cleanup:

deinit {
    NotificationCenter.default.removeObserver(self)
    // Other resource releases
}

Special considerations:

• Unregister broadcast receivers and event listeners.
• Close database and file streams.
• Cancel network requests and scheduled tasks.

Modern Memory Management Techniques

Android Jetpack Component Optimization:

• ViewModel: Stores UI-related data.
• Room: Manages database memory caching.
• Paging3: Paginates data loading.

Swift New Features:

• Value types (struct/enum) reduce reference counting overhead.
• lazy for delayed initialization to optimize memory usage.
• autoreleasepool to control automatic release pools.

// Autorelease pool example
autoreleasepool {
    let images = loadHighResolutionImages()
    process(images) // Large memory operations released immediately
}

Flutter Memory Characteristics:

• Dart VM includes built-in garbage collection.
• Cross-platform graphics engine shares texture memory.
• ImageCache controls image cache size.