Unity游戏中多个对象同时异步加载同一资源,如何避免重复发起加载?

发布人:A5数据发布时间:2026-11-17 10:32阅读量:2

多个对象在同一时间请求同一个资源时,关键是把“发起加载”从各个对象的脚本中集中起来:同一个资源键只创建一个异步加载操作,后续请求等待这次操作完成;每个请求方拿到自己的使用凭据,最后一个使用方释放时,再释放底层加载句柄。

总体思路配图

下面以 Addressables 为例实现这个流程。Addressables 可以管理资源依赖和句柄引用,但若每个对象都直接调用 LoadAssetAsync,代码仍会分别发起加载调用。封装一层共享加载器,可以合并同一地址的并发请求,并让底层句柄只在所有使用方都结束后释放一次。

用共享任务合并并发请求

加载器内部用地址作为键,保存正在加载或已加载的条目。条目包括一个 Addressables 句柄、共享的加载任务和使用计数。首次请求创建条目,后续同地址请求复用它。

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

public sealed class SharedAddressableLoader<T> where T : UnityEngine.Object
{
    private sealed class Entry
    {
        public AsyncOperationHandle<T> Handle;
        public Task<T> LoadTask;
        public int RefCount;

        public Entry(AsyncOperationHandle<T> handle)
        {
            Handle = handle;
        }
    }

    private readonly Dictionary<string, Entry> entries =
        new Dictionary<string, Entry>();

    public async Task<Lease> AcquireAsync(string address)
    {
        if (string.IsNullOrWhiteSpace(address))
        {
            throw new ArgumentException("资源地址不能为空。", nameof(address));
        }

        Entry entry;

        if (!entries.TryGetValue(address, out entry))
        {
            AsyncOperationHandle<T> handle =
                Addressables.LoadAssetAsync<T>(address);

            entry = new Entry(handle);
            entries.Add(address, entry);

            // 同一条目上的所有请求都等待这一个任务。
            entry.LoadTask = LoadEntryAsync(address, entry);
        }

        entry.RefCount++;

        T asset = await entry.LoadTask;
        return new Lease(this, address, entry, asset);
    }

    private async Task<T> LoadEntryAsync(string address, Entry entry)
    {
        try
        {
            T asset = await entry.Handle.Task;

            if (entry.Handle.Status != AsyncOperationStatus.Succeeded ||
                asset == null)
            {
                throw new InvalidOperationException(
                    "Addressables 加载失败,地址:" + address,
                    entry.Handle.OperationException);
            }

            return asset;
        }
        catch
        {
            // 失败条目只由这里清理一次,等待同一任务的请求方
            // 不要各自重复释放同一个句柄。
            Entry current;
            if (entries.TryGetValue(address, out current) &&
                ReferenceEquals(current, entry))
            {
                entries.Remove(address);
                Addressables.Release(entry.Handle);
            }

            throw;
        }
    }

    private void ReleaseReference(string address, Entry entry)
    {
        Entry current;
        if (!entries.TryGetValue(address, out current) ||
            !ReferenceEquals(current, entry))
        {
            return;
        }

        if (entry.RefCount <= 0)
        {
            return;
        }

        entry.RefCount--;

        if (entry.RefCount == 0)
        {
            entries.Remove(address);
            Addressables.Release(entry.Handle);
        }
    }

    public sealed class Lease : IDisposable
    {
        private SharedAddressableLoader<T> owner;
        private readonly string address;
        private readonly Entry entry;

        public T Asset { get; private set; }

        internal Lease(
            SharedAddressableLoader<T> owner,
            string address,
            Entry entry,
            T asset)
        {
            this.owner = owner;
            this.address = address;
            this.entry = entry;
            Asset = asset;
        }

        public void Dispose()
        {
            if (owner == null)
            {
                return;
            }

            SharedAddressableLoader<T> currentOwner = owner;
            owner = null;
            currentOwner.ReleaseReference(address, entry);
        }
    }
}

AcquireAsync 返回的不是裸资源,而是一个 Lease。每个成功的请求方持有一个 Lease;调用 Dispose 表示该方不再使用资源。所有请求方都释放后,加载器才从字典中移除条目并调用一次 Addressables.Release。

加载器应由多个对象共同使用。若每个组件各自创建一个 SharedAddressableLoader<GameObject>,各自的字典互不相通,仍然无法合并请求。可以将实例放在项目的资源服务中,或通过依赖注入传给需要它的对象:

用共享任务合并并发请求配图

public static class GameAssetServices
{
    public static readonly SharedAddressableLoader<GameObject> Prefabs =
        new SharedAddressableLoader<GameObject>();
}

在对象生命周期中取得和释放资源

组件可以在启动时申请资源,在不再使用时释放自己的租约。以下示例假设 Addressables 中存在地址为 EnemyPrefab 的 GameObject:

using System;
using UnityEngine;

public class EnemySpawner : MonoBehaviour
{
    private SharedAddressableLoader<GameObject>.Lease lease;

    private async void Start()
    {
        try
        {
            var acquired =
                await GameAssetServices.Prefabs.AcquireAsync("EnemyPrefab");

            // 异步等待期间组件可能已被销毁。
            if (this == null)
            {
                acquired.Dispose();
                return;
            }

            lease = acquired;
            Instantiate(lease.Asset, transform);
        }
        catch (Exception exception)
        {
            Debug.LogException(exception);
        }
    }

    private void OnDestroy()
    {
        if (lease != null)
        {
            lease.Dispose();
            lease = null;
        }
    }
}

如果多个 EnemySpawner 几乎同时请求 EnemyPrefab,第一个请求会调用一次 Addressables.LoadAssetAsync<GameObject>,其余请求会等待同一个 LoadTask。加载成功后,各组件分别得到一个租约,但它们对应的是同一条目和同一个底层句柄。某个组件先销毁,只会减少一次引用计数;最后一个组件释放租约时,加载器才释放句柄。

这里要让租约覆盖资源的实际使用周期。若组件创建的对象会在组件销毁后继续使用资源,不要在组件销毁时过早释放租约;应由更长寿命的管理对象持有它,或调整对象与租约的所有权关系。Lease.Dispose 设计为可重复调用而不重复扣减,但释放后应视为不再持有资源,不要继续依赖 Asset。

在对象生命周期中取得和释放资源配图

几个容易影响结果的边界

只合并同一个加载键

字典按地址字符串匹配。若同一资源在项目中能通过多个不同地址、AssetReference 或其他键访问,加载器会把它们视为不同请求,无法保证合并。项目应为需要共享的资源确定统一键,并让所有调用方使用同一个键。

示例中的加载器是泛型类型,不同类型的加载器各有一份字典。因此,对同一地址分别使用 SharedAddressableLoader<GameObject> 和 SharedAddressableLoader<Texture2D>,会产生各自的加载调用。调用方也应保持类型一致,并确认传入地址对应目标类型的资源。

并发合并不等于长期缓存

最后一个租约释放后,条目会被移除。之后再次请求同一地址,会创建新的加载操作。这种做法解决的是“请求时间重叠时重复发起加载”,而不是跨场景或跨时间永久缓存。

如果应用需要在一段空闲时间内继续复用已加载资源,可以额外设计缓存保留策略,例如空闲保留时长、显式预加载和场景级资源所有权。保留句柄也意味着资源仍被持有,不能只把条目留在字典里而忽略何时释放。Addressables 对下载内容和依赖的管理也不等于应用层的无限期资源缓存。

加载失败后允许重试

首次加载失败时,加载器会移除失败条目并释放句柄;等待这次加载的请求都会收到异常。之后的新请求可以重新创建条目并再次尝试。调用方需要捕获异常并决定如何反馈或重试,不能把失败当作成功后继续访问资源。

示例用 async void Start 是因为 Unity 生命周期回调通常不能直接返回 Task,因此在方法内捕获了异常。普通业务方法更适合返回 Task,由上层统一处理错误。若要加入用户取消,也不要因为单个对象取消等待就直接取消共享的底层加载:同一加载可能仍被其他对象使用。取消通常应先解除该请求方的等待或所有权,再根据剩余使用方决定何时释放资源。

加载器的线程约定

字典访问、Addressables 调用以及租约释放都应在 Unity 主线程进行。示例从主线程调用 AcquireAsync,并在 await 后继续执行 Unity 对象操作;不要在后台线程直接调用这些方法或 Dispose。如果项目自行改变了任务的上下文切换方式,需要保证对 Unity API 和共享字典的访问仍符合主线程要求。

示例使用 AsyncOperationHandle<T>.Task。若目标平台或项目所用 Addressables 环境不支持这一路径,应改用 Completed 回调或协程等待;合并方式不变:字典条目仍保存唯一的底层操作,后续请求仍复用该条目的完成结果。

如何验证是否合并成功

可以在 Addressables.LoadAssetAsync<T> 前临时记录地址和调用次数,然后让多个对象在同一帧或相邻帧对同一地址调用 AcquireAsync。预期现象是:加载器只记录一次底层调用,各对象都在加载完成后拿到租约;逐个销毁对象时,资源不会因第一个对象释放而提前解除持有;最后一个租约释放后,条目才从加载器中移除。

如何验证是否合并成功配图

这里核对的是应用层的 Addressables 加载调用数,不应直接把它等同于网络下载次数。Addressables 对资源包、依赖和下载缓存有自己的管理;共享加载器的目标是避免项目脚本对同一键重复创建加载入口,并统一句柄的所有权与释放时机。若项目使用 Resources.LoadAsync 或自建 AssetBundle 管理器,也可以采用“键到共享操作、请求方计数、最后一个使用方释放”的结构,但底层句柄类型、资源卸载方式和失败处理需要按对应 API 实现。

游戏资源的实际下载与分发,还涉及资源包发布和访问链路。A5数据提供CDN及香港、日本、美国等地区的服务器资源,可用于游戏静态资源分发,并为相关业务服务或资源源站提供部署选择,支持游戏内容面向不同地区的交付与运行。

本文由A5数据原创发布,转载请注明出处:https://www.a5idc.com/helpcontent/9915.html

相关推荐