Unity对象池

---

对象池是什么？

对象池，顾名思义就是一个装对象的池子。在我们做游戏的时候，比如一些射击游戏常常会生成出很多的子弹。也要销毁子弹。对象池的概念就是先生成一些对象到池子里，需要使用的时候就显示出来，不需要使用就隐藏而不是销毁它。

---

一、使用步骤

1.使用对象池

新建一个脚本：

/// <summary>
/// 对象池
/// </summary>
public class ObjectPool : MonoBehaviour
{
    //使用单例模式
    public static ObjectPool Instance;
    public GameObject prafab;//被实例的对象
    private Queue<GameObject> pools = new Queue<GameObject>();//存放对象的池

    private void Awake()
    {
         if(Instance!=null)
        {
            Destroy(gameObject);
        }
        else
        {
            Instance = this;
        }
    }


    void Start()
    {
            InitPool(10, prafab);//初始化
    }
    public void Update()
    {
        //按下K键，从对象池中拿出一个对象
        if(Input.GetKeyDown(KeyCode.K))
        {

        }
    }

  /// <summary>
  /// 初始化对象池
  /// </summary>
  /// <param name="_count">数量</param>
  /// <param name="obj">要被实例对象</param>
    public void InitPool(int _count,GameObject obj)
    {
        for (int i = 0; i < _count; i++)
        {
            GameObject go = Instantiate(obj);//实例化对象
            go.SetActive(false);//隐藏对象
            pools.Enqueue(go);//放入对象池
        }
    }

    /// <summary>
    /// 从对象池拿取对象
    /// </summary>
    /// <returns>对象</returns>
    public GameObject GetObjectToPool()
    {
        //如果对象池还有对象
        if(pools.Count>0)
        {
            GameObject go=pools.Dequeue();//从对象池拿出对象
            go.SetActive(true);//显示对象
            return go;
        }
        //如果对象池里没有对象了
        return null;   
    }
}

这样，对象池就新建好了。给脚本一个对象，再运行unity就可以发现对象已经生成在场景中了。（如果感觉太乱了，就在生成的时候设置父类。注：拿出的时候也要记得清空它的父类！）

只需要修改这两个方法：

  /// <summary>
  /// 初始化对象池
  /// </summary>
  /// <param name="_count">数量</param>
  /// <param name="obj">要被实例对象</param>
    public void InitPool(int _count,GameObject obj)
    {
        for (int i = 0; i < _count; i++)
        {
            GameObject go = Instantiate(obj);//实例化对象
            go.SetActive(false);//隐藏对象
            go.transform.SetParent(transform);//设置父类
            pools.Enqueue(go);//放入对象池
        }
    }

   /// <summary>
    /// 从对象池拿取对象
    /// </summary>
    /// <returns>对象</returns>
    public GameObject GetObjectToPool()
    {
        //如果对象池还有对象
        if(pools.Count>0)
        {
           GameObject go=pools.Dequeue();//从对象池拿出对象
            go.transform.SetParent(null);//清空父类
            go.SetActive(true);//显示对象
            return go;
        }

        //如果对象池里没有对象了
        return null;   
    }

2.把对象放回对象池

上面的代码只写了初始化对象池和从对象池里拿取对象，还少了把对象放回对象池的方法。为了测试，我给脚本加上了一个坐标点，按下K键就把对象生成在坐标点上。下方为完整代码

/// <summary>
/// 对象池
/// </summary>
public class ObjectPool : MonoBehaviour
{
    //使用单例模式
    public static ObjectPool Instance;
    public GameObject prafab;//被实例的对象
    public Transform point;//要被生成的点
    private Queue<GameObject> pools = new Queue<GameObject>();//存放对象的池

    private void Awake()
    {
         if(Instance!=null)
        {
            Destroy(gameObject);
        }
        else
        {
            Instance = this;
        }
    }


    void Start()
    {
        InitPool(10, prafab);
    }


    public void Update()
    {
        //按下K键，从对象池中拿出一个对象
        if(Input.GetKeyDown(KeyCode.K))
        {
           GameObject go=GetObjectToPool();
            go.transform.position = point.position;
        }
    }

  /// <summary>
  /// 初始化对象池
  /// </summary>
  /// <param name="_count">数量</param>
  /// <param name="obj">要被实例对象</param>
    public void InitPool(int _count,GameObject obj)
    {
        for (int i = 0; i < _count; i++)
        {
            GameObject go = Instantiate(obj);//实例化对象
            go.SetActive(false);//隐藏对象
            go.transform.SetParent(transform);//设置父类
            pools.Enqueue(go);//放入对象池
        }
    }

    /// <summary>
    /// 从对象池拿取对象
    /// </summary>
    /// <returns>对象</returns>
    public GameObject GetObjectToPool()
    {
        //如果对象池还有对象
        if(pools.Count>0)
        {
           GameObject go=pools.Dequeue();//从对象池拿出对象
            go.transform.SetParent(null);//清空父类
            go.SetActive(true);//显示对象
            return go;
        }

        //如果对象池里没有对象了
        return null;   
    }

    /// <summary>
    /// 把对象放回对象池
    /// </summary>
    /// <param name="obj">要放回的对象</param>
   public void BackToPool(GameObject obj)
    {
        obj.SetActive(false);//隐藏对象
        obj.transform.position = Vector3.zero;//坐标清零
        obj.transform.SetParent(transform);//设置父类
        pools.Enqueue(obj);//放入对象池
    }
}

虽然有了把对象放回对象池的方法 ，但是应该在什么时候调用它呢？我们可以在对象需要被 ”销毁“ 的时候，当然不是真的销毁，而是放入对象池中。
新建一个用于控制对象的脚本：

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

public class ObjectTest : MonoBehaviour
{
    private float time;//生命时间

    private void OnEnable()//每次启用这个对象，就会给生命时间赋值
    {
        time = 2f;
    }


    private void Update()
    {
        time -= Time.deltaTime;
        if(time<=0)//当生命时间小于或等于零
        {
            ObjectPool.Instance.BackToPool(gameObject);//放回对象池
        }
        
    }
}

把这个脚本挂到对象池的对象上就ok啦。

对象池测试