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

下面以 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
