【学习笔记】 多线程资源管理器（附流程图附源码）

《奇怪的大冒险》教程视频连接：
http://www.taikr.com/course/222
笔记结合了前7课的视频内容，感谢新总提供的免费视频
PS：部分字段、属性和方法的命名与视频教程中有出入。

资源管理器核心的集合一共有三个：

1.等待加载的资源队列

private Queue <ResLoadRequest> m_QueWaitLoadAsset = new Queue< ResLoadRequest >();

2.当前正在加载的资源列表

private List <ResLoadRequest> m_LstLoadingAsset = new List< ResLoadRequest >();

3.已经完成加载的资源字典

private Dictionary <string, AssetPack > m_DicLoadedAsset = new Dictionary< string , AssetPack >();

资源管理器的核心思想就是通过操作这三个集合，进行资源的加载，持有及释放。

三个集合的类型，可以看到明显的差异。

集合 <等待加载> 和 <正在加载> 的元素类型均为 ResLoadRequest类（资源加载数据类）

集合 <完成加载> 的元素类型为 AssetPack类（资源包类）

先从几个集合的转换，做个简要介绍

然后是资源管理器的流程图：

框架层级的东西，单纯看代码比较难以理解，所以我比较喜欢画图记忆，大体原理掌握了，自己也可以写出来了~！

在这基础上还可以增加AssetBundle的资源管理器。

另附本次学习的资源管理器代码

// **********************************************************************
// 
// 文件名(File Name)：             ResMgr.cs
// 
// 作者（Author)：                 沐小沫
// 
// 日期（Create Date):             2015-07-10
// 
// **********************************************************************

using UnityEngine;
using System.Collections;
using System;
using System.Collections.Generic;
using UnityEngine.EventSystems;

public class ResMgr : MonoBehaviour
{
    private static ResMgr m_Instance = null;                // 静态实例
    /// <summary>
    /// 获取静态实例
    /// </summary>
    /// <returns>静态实例</returns>
    public static ResMgr GetInstance()
    {
        return m_Instance;
    }

    private GameObject m_CachedGameObject;                  // 缓存对象
    private GameObject CachedGameObject
    {
        get
        {
            if (null == m_CachedGameObject && null != m_Instance)
            {
                m_CachedGameObject = this.gameObject;
            }

            return m_CachedGameObject;
        }
    }

    private static int m_ProcessorCount = 0;                // 线程数量
    private static int ProcessorCount
    {
        set { m_ProcessorCount = Mathf.Clamp(value, 1, 8); }
        get { return m_ProcessorCount; }
    }

    void Awake()
    {
        ProcessorCount = SystemInfo.processorCount;
        DontDestroyOnLoad(CachedGameObject);
        m_Instance = this;
    }

    /// <summary>
    /// 当前正在加载的资源列表
    /// </summary>
    private List<ResLoadRequest> m_LstLoadingAsset = new List<ResLoadRequest>();

    /// <summary>
    /// 等待加载的资源队列
    /// </summary>
    private Queue<ResLoadRequest> m_QueWaitLoadAsset = new Queue<ResLoadRequest>();

    /// <summary>
    /// 已经完成加载的资源字典
    /// </summary>
    private Dictionary<string, AssetPack> m_DicLoadedAsset = new Dictionary<string, AssetPack>();

   
    /// <summary>
    /// 从Resources中加载一个资源
    /// </summary>
    /// <param name="assetName">资源名称</param>
    /// <param name="assetType">资源类型</param>
    /// <param name="loadListeners">加载完成的监听接口</param>
    /// <param name="isKeepInMemory">是否常驻内存</param>
    public void LoadAsset(string assetName, ILoadListeners loadListeners, Type assetType = null, bool isKeepInMemory = false)
    {
        if(string.IsNullOrEmpty(assetName))
        {
            if (null != loadListeners)
            {
                loadListeners.Failure();
            }
            return;
        }

        if (m_DicLoadedAsset.ContainsKey(assetName))
        {
            if (null != loadListeners)
            {
                loadListeners.Success(m_DicLoadedAsset[assetName].m_Asset);
            }
            return;
        }

        for (int i = 0; i < m_LstLoadingAsset.Count; i++)
        {
            ResLoadRequest request = m_LstLoadingAsset[i];
            if (request.m_AssetName.Equals(assetName))
            {
                request.AddListeners(loadListeners);
                return;
            }
        }

        foreach (ResLoadRequest request in m_QueWaitLoadAsset)
        {
            if (request.m_AssetName.Equals(assetName))
            {
                request.AddListeners(loadListeners);
                return;
            }
        }

        ResLoadRequest loadRequest = new ResLoadRequest(assetName, isKeepInMemory, assetType);
        loadRequest.AddListeners(loadListeners);
        m_QueWaitLoadAsset.Enqueue(loadRequest);
    }

    /// <summary>
    /// 从资源队列中处理待加载的资源
    /// </summary>
    public void Update()
    {
        if(m_LstLoadingAsset.Count > 0)
        {
            for(int i = m_LstLoadingAsset.Count - 1; i >= 0 ; i--)
            {
                if (m_LstLoadingAsset[i].IsLoadedDone)
                {
                    LoadAssetFinish(m_LstLoadingAsset[i]);
                    m_LstLoadingAsset.RemoveAt(i);
                }
            }
        }

        while (m_LstLoadingAsset.Count < ProcessorCount && m_QueWaitLoadAsset.Count > 0)
        {
            ResLoadRequest request = m_QueWaitLoadAsset.Dequeue();
            m_LstLoadingAsset.Add(request);
            request.LoadAsync();
        }
    }

    /// <summary>
    /// 资源加载完毕
    /// </summary>
    void LoadAssetFinish(ResLoadRequest request)
    {
        if(null != request)
        {
            for (int i = 0; i < request.m_LstListeners.Count; i++)
            {
                ILoadListeners listeners = request.m_LstListeners[i];

                if (null != listeners)
                {
                    if (null != request.m_Request && null != request.Asset)
                    {
                        listeners.Success(request.Asset);

                        AssetPack pack = new AssetPack(request.m_AssetType, request.m_IsKeepInMemory);
                        pack.m_Asset = request.Asset;
                        m_DicLoadedAsset.Add(request.m_AssetName, pack);
                    }
                    else
                    {
                        listeners.Failure();
                    }
                }
            }

        }
    }
    
    /// <summary>
    /// 释放指定的资源
    /// </summary>
    /// <param name="assetName">资源名字</param>
    /// <param name="canRealseKeepInMemory">是否可以释放常驻内存的资源</param>
    public void ReleaseAsset(string assetName, bool canRealseKeepInMemory)
    {
        if (!m_DicLoadedAsset.ContainsKey(assetName))
        {
            return;
        }

        if (m_DicLoadedAsset[assetName].m_IsKeepInMemory && !canRealseKeepInMemory)
        {
            return;
        }

        m_DicLoadedAsset[assetName] = null;
        m_DicLoadedAsset.Remove(assetName);

        Resources.UnloadUnusedAssets();
    }

    /// <summary>
    /// 释放全部资源
    /// </summary>
    public void ReleaseAllAsset()
    {
        foreach (KeyValuePair<string, AssetPack> pair in m_DicLoadedAsset)
        {
            m_DicLoadedAsset[pair.Key] = null;
        }

        m_DicLoadedAsset.Clear();
        Resources.UnloadUnusedAssets();
    }

#region 资源加载数据类
    /// <summary>
    /// 加载类
    /// </summary>
    public class ResLoadRequest
    {
        /// <summary>
        /// 资源名称
        /// </summary>
        public string m_AssetName;

        /// <summary>
        /// 资源类型
        /// </summary>
        public Type m_AssetType;

        /// <summary>
        /// 监听接口
        /// </summary>
        public List<ILoadListeners> m_LstListeners = new List<ILoadListeners>();

        /// <summary>
        /// 加载资源请求
        /// </summary>
        public ResourceRequest m_Request;

        /// <summary>
        /// 是否常驻内存
        /// </summary>
        public bool m_IsKeepInMemory;

        /// <summary>
        /// 重载构造函数
        /// </summary>
        /// <param name="assetName">资源名称</param>
        /// <param name="isKeepInMemory">是否常驻内存</param>
        /// <param name="assetType">资源类型</param>
        public ResLoadRequest(string assetName, bool isKeepInMemory, Type assetType)
        {
            this.m_AssetName = assetName;
            this.m_IsKeepInMemory = isKeepInMemory;
            this.m_AssetType = assetType;
        }

        /// <summary>
        /// 添加一个监听到监听列表
        /// </summary>
        /// <param name="listeners">监听接口</param>
        public void AddListeners(ILoadListeners listeners)
        {
            if (listeners == null)
            {
                return;
            }

            if(!m_LstListeners.Contains(listeners))
            {
                m_LstListeners.Add(listeners);
            }
        }

        /// <summary>
        /// 加载到的资源
        /// </summary>
        public UnityEngine.Object Asset
        {
            get
            {
                if (null != m_Request && null != m_Request.asset)
                {
                    return m_Request.asset;
                }
                else
                {
                    return null;
                }
            }
        }

        /// <summary>
        /// 当前是否已经加载完成
        /// </summary>
        public bool IsLoadedDone
        {
            get { return (null != m_Request && m_Request.isDone); }
        }

        /// <summary>
        /// 异步加载资源
        /// </summary>
        public void LoadAsync()
        {
            if (null == m_AssetType)
            {
                m_AssetType = typeof(GameObject);
            }

            m_Request = Resources.LoadAsync(m_AssetName, m_AssetType);
        }
    }

    /// <summary>
    /// 资源包
    /// </summary>
    public class AssetPack
    {
        /// <summary>
        /// 资源类型
        /// </summary>
        public Type m_AssetType;

        /// <summary>
        /// 是否常驻内存
        /// </summary>
        public bool m_IsKeepInMemory;

        /// <summary>
        /// 资源
        /// </summary>
        public UnityEngine.Object m_Asset;

        public AssetPack(Type assetType, bool isKeepInMemory)
        {
            m_AssetType = assetType;
            m_IsKeepInMemory = isKeepInMemory;
        }
    }
#endregion

#region 加载资源完成后监听接口

    public interface ILoadListeners
    {
        /// <summary>
        /// 加载成功
        /// </summary>
        /// <param name="asset">资源</param>
        void Success(UnityEngine.Object asset);

        /// <summary>
        /// 加载失败
        /// </summary>
        void Failure();
    }

#endregion
}