unity之 协程Coroutine VS 定时器

unity协程Coroutine 大家并不陌生，在项目中也是经常使用。大量的使用协程，会影响性能，带来GC。

如下图 延迟调用 所带来的的GC：

 

因此 对于延迟调用 ，最好不要用 协程 Coroutine，最好自己用update 去实现。

自己写定时器有哪些优点：

1.减少GC

2.可以自己写回调，开始执行，执行中，执行完毕回调。

3.可以循环次数、暂定、停止、恢复、循环间隔时间、剩余循环次数。

根据以上的需求，该如何设计出一个优雅且好用的定时器呢？

 

 

 

定时器：

using System;

/// <summary>
/// 定时器
/// </summary>
public class TestTimeAction
{
    /// <summary>
    /// 定时器名字
    /// </summary>
    private string m_Name;

    /// <summary>
    /// 定时器名字
    /// </summary>
    internal string Name
    {
        get { return m_Name; }
    }

    /// <summary>
    /// 延迟时间
    /// </summary>
    private float m_DelayTime;

    /// <summary>
    /// 循环次数 -1:无线循环  0：循环一次  >0:循环次数
    /// </summary>
    private int m_LoopTimes;

    /// <summary>
    /// 已循环次数
    /// </summary>
    private int m_AlreadyTimes;

    /// <summary>
    /// 间隔
    /// </summary>
    private float m_Interval;

    /// <summary>
    /// 是否正在运行
    /// </summary>
    public bool IsRuning
    {
        get;
        private set;
    }

    /// <summary>
    /// 是否暂定中
    /// </summary>
    private bool m_IsPause = false;

    /// <summary>
    /// 最后暂停时间
    /// </summary>
    private float m_LastPauseTime;

    /// <summary>
    /// 暂停了多久
    /// </summary>
    private float m_PauseTime;

    /// <summary>
    /// 当前时间
    /// </summary>
    private float m_CurrTime;

    //开始、运行中、完成回调
    public Action OnStartFun { get; private set; }
    public Action<int> OnDoingFun { get; private set; }//剩余次数
    public Action OnCompleteFun { get; private set; }

    /// <summary>
    /// 初始化
    /// </summary>
    internal TestTimeAction Init(string name, float delayTime, int loopTimes, float interval, Action startFun, Action<int> doingFun, Action completeFun)
    {
        m_Name = name;
        m_DelayTime = delayTime;
        m_LoopTimes = loopTimes;
        m_Interval = interval;
        OnStartFun = startFun;
        OnDoingFun = doingFun;
        OnCompleteFun = completeFun;
        return this;
    }

    /// <summary>
    /// 运行
    /// </summary>
    public void Run()
    {
        TestGameEntry.TimeMgr.RegisterTimeAction(this);
        m_CurrTime = UnityEngine.Time.time;
        m_IsPause = false;
    }

    /// <summary>
    /// 暂停
    /// </summary>
    public void Pause()
    {
        if (m_IsPause) return;
        m_LastPauseTime = UnityEngine.Time.time;
        m_IsPause = true;
    }

    /// <summary>
    /// 恢复
    /// </summary>
    public void Resume()
    {
        m_IsPause = false;
        //计算暂停多久
        m_PauseTime = UnityEngine.Time.time - m_LastPauseTime;
    }

    /// <summary>
    /// 停止
    /// </summary>
    private void Stop()
    {
        IsRuning = false;
        OnCompleteFun?.Invoke();
        TestGameEntry.TimeMgr.RemoveTimeAction(this);
    }

    internal void OnUpdate()
    {
        if (m_IsPause) return;
        //开始运行
        if (UnityEngine.Time.time > m_CurrTime + m_DelayTime + m_PauseTime)
        {
            if (!IsRuning)
            {
                IsRuning = true;
                m_CurrTime = UnityEngine.Time.time;
                m_PauseTime = 0;
                OnStartFun?.Invoke();
            }
        }
        if (!IsRuning) return;
        //运行中
        if (UnityEngine.Time.time > m_CurrTime + m_PauseTime)
        {
            m_CurrTime = UnityEngine.Time.time + m_Interval;
            m_PauseTime = 0;
            OnDoingFun?.Invoke(m_LoopTimes - m_AlreadyTimes);
            if (m_LoopTimes > -1)
            {
                m_AlreadyTimes++;
                if (m_AlreadyTimes >= m_LoopTimes)
                {
                    Stop();
                }
            }
        }
    }
}

 

时间管理器：

using System.Collections.Generic;

public class TestTimeManager : System.IDisposable
{
    private LinkedList<TestTimeAction> testTimeActions;

    internal void Init()
    {
        testTimeActions = new LinkedList<TestTimeAction>();
    }

    public TestTimeAction CreateTimeAction()
    {
        TestTimeAction timeAction = new TestTimeAction();
        return timeAction;
    }


    public void RegisterTimeAction(TestTimeAction timeAction)
    {
        testTimeActions.AddLast(timeAction);
    }

    public void RemoveTimeAction(TestTimeAction timeAction)
    {
        if (testTimeActions.Contains(timeAction))
        {
            testTimeActions.Remove(timeAction);
        }
    }
    public void RemoveTimeActionByName(string name)
    {
        for (var v = testTimeActions.First; v.Next != null; v = v.Next)
        {
            if (v.Value.Name.Equals(name, System.StringComparison.CurrentCultureIgnoreCase))
            {
                testTimeActions.Remove(v.Value);
                break;
            }
        }
    }

    public void OnUpdate()
    {
        for (var v = testTimeActions.First; v != null; v = v.Next)
        {
            if (v.Value.OnStartFun.Target == null || v.Value.OnStartFun.Target.ToString() == "null")
            {
                testTimeActions.Remove(v);
                continue;
            }
            if (v.Value.OnDoingFun.Target == null || v.Value.OnDoingFun.Target.ToString() == "null")
            {
                testTimeActions.Remove(v);
                continue;
            }
            if (v.Value.OnCompleteFun.Target == null || v.Value.OnCompleteFun.Target.ToString() == "null")
            {
                testTimeActions.Remove(v);
                continue;
            }
            v.Value.OnUpdate();
        }
    }

    public void Dispose()
    {
        testTimeActions.Clear();
    }
}

 

测试入口

using UnityEngine;

public class TestGameEntry : MonoBehaviour
{
    public static TestGameEntry Instance;
    public static TestTimeManager TimeMgr { get; private set; }
    private void Awake()
    {
        Instance = this;
    }

    void Start()
    {
        InitManagers();
        Init();
    }

    void InitManagers()
    {
        TimeMgr = new TestTimeManager();
    }

    void Init()
    {
        TimeMgr.Init();
    }

    void Update()
    {
        TimeMgr.OnUpdate();
    }

    private void OnDestroy()
    {
        TimeMgr.Dispose();
    }
}

 

测试用例：

if (Input.GetKeyUp(KeyCode.A))
        {
            timeAction = TestGameEntry.TimeMgr.CreateTimeAction();
            Debug.Log("创建了定时器time1");
            if (timeAction == null) return;
            timeAction.Init("time1", 10f, 100, 1f, () =>
             {
                 Debug.Log("time1 开始执行");
             }, (int times) =>
             {
                 Debug.Log(string.Format("time1 运行中,剩余{0}次", times));
             }, () =>
             {
                 Debug.Log("time1 完成");
             }).Run();
        }

        if (Input.GetKeyUp(KeyCode.P))
        {
            if (timeAction == null) return;
            timeAction.Pause();
            Debug.LogError("暂停");
        }

        if (Input.GetKeyUp(KeyCode.R))
        {
            if (timeAction == null) return;
            timeAction.Resume();
            Debug.LogError("恢复");
        }

 

 

 欢迎大家提出批评建议和指教哈~