Eliminating main thread freezes (spikes) and asynchronous load delays with LZMA decompression when loading Addressables/AssetBundles

2. Solution approach: Steps to migrate to LZ4 (Chunk-based) compression

The most effective approach to completely eliminate this load spike is to change the compression setting for the Addressables group from "LZMA" to "LZ4". LZ4 uses "chunk-based compression", which divides files into small blocks (chunks) and compresses them individually. When loading an asset, we only decompress the specific chunk in which the asset is stored, minimizing the memory and time required for decompression and completely eliminating main thread spikes.

Step 1: Change settings in the Addressables Groups window

1. Open Window > Asset Management > Addressables > Groups from the Unity editor menu.
2. Select the group of interest (for example: Default Local Group) and look at the Inspector window.
3. Find the Bundle Compression setting in the Content Packing & Loading section.
4. Change the setting value from LZMA to LZ4 (or Uncompressed).

Step 2: Safe implementation of asynchronous loading and cache management

In addition to changing the compression format, the C# code also needs to smartly control asynchronous loading and properly separate the loading and instantiation (creation) loads. Below is an example implementation of a robust manager class to safely load and cache assets asynchronously while preventing spikes.

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class AddressableAssetLoader : MonoBehaviour
{
    // Cache dictionary to prevent double loading of assets
    private Dictionary<string, AsyncOperationHandle> _loadedAssets = new Dictionary<string, AsyncOperationHandle>();

    /// <summary>
    /// Safely load assets asynchronously (does not block the main thread)
    /// </summary>
    public void LoadAssetSafe<T>(string address, Action<T> onComplete) where T : UnityEngine.Object
    {
        // Immediate return from cache if already loaded
        if (_loadedAssets.TryGetValue(address, out AsyncOperationHandle existingHandle))
        { 
            if (existingHandle.IsDone && existingHandle.Status == AsyncOperationStatus.Succeeded)
            {
                onComplete?.Invoke(existingHandle.Result as T);
                return;
            }
        }

        // Start an asynchronous load request
        AsyncOperationHandle<T> handle = Addressables.LoadAssetAsync<T>(address);
        _loadedAssets[address] = handle;

        handle.Completed += (op) =>
        {
            if (op.Status == AsyncOperationStatus.Succeeded)
            {
                // Execute callback on main thread when loading completes
                onComplete?.Invoke(op.Result);
            }
            else
            { 
                Debug.LogError($"[Loader] アセットのロードに失敗しました: {address}");
                _loadedAssets.Remove(address);
            }
        };
    }

    /// <summary>
    /// Asset memory release process
    /// </summary>
    public void ReleaseAsset(string address)
    {
        if (_loadedAssets.TryGetValue(address, out AsyncOperationHandle handle))
        { 
            Addressables.Release(handle);
            _loadedAssets.Remove(address);
            Debug.Log($"[Loader] アセットをアンロードしました: {address}");
        }
    }

    private void OnDestroy()
    {
        // Safely release all loaded assets at once during scene transition or object destruction
        foreach (var handle in _loadedAssets.Values)
        { 
            Addressables.Release(handle);
        }
        _loadedAssets.Clear();
    }
}

3. “Road spike prevention checklist” useful in practice

As a countermeasure for processing failures related to asset management, we have summarized important points that should be confirmed before release.

Summary: For comfortable loading

Don't feel safe just because you are using an asynchronous load API; it is important to always be aware of the internal behavior (LZMA vs LZ4, etc.) of ``How assets are decompressed behind the scenes and when they are expanded to memory.''

Especially in environments where thermal throttling (deterioration in performance due to thermal runaway) is prone to occur, such as smartphones and standalone VR, the accumulation of these decompression spikes can directly lead to forced termination of apps, stuttering, and ultimately a decrease in user satisfaction. Build a stress-free and comfortable asset loading environment by leveraging appropriate group settings and asynchronous manager class caching.