Unity 减低GC和优化

1. 对象池：

   • 实例：频繁创建和销毁大量临时对象，如游戏中的子弹、特效等，会引发大量的GC操作。为避免这种情况，可以使用对象池技术。当一个对象不再需要时，不立即销毁它，而是将其放入池中待复用，这样可以显著减少新对象的创建和旧对象的销毁带来的内存分配与回收。

   public class BulletPool : MonoBehaviour
   {
       private Queue<Bullet> availableBullets = new Queue<Bullet>();
   
       public void GetBullet(out Bullet bullet)
       {
           if (availableBullets.Count > 0)
           {
               bullet = availableBullets.Dequeue();
               bullet.gameObject.SetActive(true);
           }
           else
           {
               bullet = Instantiate(bulletPrefab);
           }
       }
   
       public void ReturnBullet(Bullet bullet)
       {
           bullet.gameObject.SetActive(false);
           availableBullets.Enqueue(bullet);
       }
   }
   
   // 在使用时：
   Bullet bullet;
   bulletPool.GetBullet(out bullet);
   // 使用完后：
   bulletPool.ReturnBullet(bullet);
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29

2. 字符串操作优化：

   • 实例：频繁拼接字符串会生成新的字符串对象，从而触发GC。改用StringBuilder类进行动态字符串构建。

   // 非优化版本
   string result = "";
   for (int i = 0; i < 1000; i++)
   {
       result += "Value: " + i.ToString(); // 每次循环都会创建新的字符串对象
   }
   
   // 优化版本
   StringBuilder sb = new StringBuilder();
   for (int i = 0; i < 1000; i++)
   {
       sb.Append("Value: ").Append(i); // 使用StringBuilder避免每次循环都创建新字符串
   }
   string result = sb.ToString();
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

3. 避免大型结构体数组的临时创建：

   • 实例：访问Unity引擎内部组件或属性时，有时会返回托管堆上的数组，例如Mesh.normals。这类访问可能导致意外的对象分配。应该尽量缓存这些结果以供后续重复使用。

   // 非优化版本
   Vector3[] normals = mesh.normals; // 每次访问可能重新分配数组
   
   // 优化版本
   private Vector3[] cachedNormals;
   void Awake()
   {
       cachedNormals = mesh.normals;
   }
   void SomeMethodRequiringNormals()
   {
       // 使用缓存的数组
       foreach (var normal in cachedNormals)
       {
           // ...
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17

4. 预初始化集合大小：

   • 实例：对于List或其他可变大小的集合，如果知道大概的元素数量，提前设置容量能防止自动扩容时产生的多余内存分配和GC压力。

   // 非优化版本
   List<int> list = new List<int>();
   for (int i = 0; i < 10000; i++) 
   {
       list.Add(i); // 可能多次自动扩容
   }
   
   // 优化版本
   List<int> optimizedList = new List<int>(10000);
   for (int i = 0; i < 10000; i++) 
   {
       optimizedList.Add(i); // 不会发生自动扩容
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13

5. 重用单例和静态变量：

   • 实例：在场景切换、全局计算或一次性初始化时，避免使用瞬态对象。通过单例模式或静态变量存储一些长期使用的对象或数据结构。

   // 单例示例
   public sealed class GameManager : MonoBehaviour
   {
       private static GameManager _instance;
   
       public static GameManager Instance
       {
           get { return _instance ?? (_instance = FindObjectOfType<GameManager>()); }
       }
   
       private readonly Dictionary<string, GameObject> prefabCache = new Dictionary<string, GameObject>();
   
       void Awake()
       {
           if (_instance != null && _instance != this)
           {
               Destroy(gameObject);
               return;
           }
           _instance = this;
   
           // 预加载并缓存prefabs，防止运行时反复加载资源导致GC
           foreach (var prefabPath in prefabNames)
           {
               var prefab = Resources.Load<GameObject>(prefabPath);
               prefabCache[prefabPath] = prefab;
           }
       }
   
       public GameObject GetCachedPrefab(string path)
       {
           return prefabCache.TryGetValue(path, out var prefab) ? prefab : null;
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34

通过上述实例可以看出，Unity中的GC优化主要围绕着减少临时对象的创建、有效利用已存在的对象和结构以及合理管理内存分配来进行。同时，在编写代码时应遵循内存安全编程的原则，注意引用类型与值类型的合理使用，以及避免使用可能导致装箱操作的API。

python推荐学习汇总连接：
50个开发必备的Python经典脚本(1-10)

50个开发必备的Python经典脚本(11-20)

50个开发必备的Python经典脚本(21-30)

50个开发必备的Python经典脚本(31-40)

50个开发必备的Python经典脚本(41-50)
————————————————

​最后我们放松一下眼睛