【转载】Unity协程深入及实现
Unity协程深入参考
Unity协程简介
Unity中的协程能够允许我们将一个任务分散到多个帧中。注意：协程（协同执行）和多线程有本质区别。 协程不是线程，协程执行过程中仍然是在主线程中执行。协程实际上是Unity利用 C# 中的yield关键字来帮忙提供的一套模拟多线程的机制。
Unity协程的用法
首先来看下一个简单的协程示例， 下面代码在案下“f”后开启一个协程。
```csharp
class Example : MonoBehaviour
{
void Update()
{
if (Input.GetKeyDown("f"))
{
StartCoroutine(Test());
}
}
IEnumerator Test()
{
yield retunr null;
Debug.Log("print 1");
yield return new WaitForSeconds(.1f);
Debug.Log("print 2");
}
}
```
我们可以看到 Test 方法的返回值是 IEnumerator,这是C#提供的迭代器，而中间的 yield return 则是语法糖，帮我们简化处理迭代器的内容。具体的迭代器相关文章可以看这里.
注意：
协程启动提供了字符串的方法，只有通过字符串方法启动的才能通过字符串方式停止。另外通过这种方法内部肯定是用了反射的方式，不太推荐。
协程开启需要额外的内存开销来跟踪对象，如果非常频繁（例如每一帧）那么使用Update或LateUpdate能获得更高的性能。
协程的原理
我们知道游戏是通过一帧一帧来运行的， 那么协程是运行在哪里呢？。在Untiy官方帮助文档中给出了脚本生命周期流程图。大致的位置就是在Update和LateUpdate之间。
协程大致有如下几种：
```csharp
yield return null; // 暂停协程等待下一帧继续执行
yield return 1; // 或其他数字 暂停协程等待下一帧继续执行
yield return new WairForSeconds(1); // 等待规定时间后继续执行
yield return DoCoroutine(); // 嵌套开启一个协程
```
协程的缺陷
依赖于MonoBehaviour
不能有返回值
回调复杂
自己实现协程
知道了协程的实现方法后我们可以知道实际上是可以脱离unity自行模拟协程相关的内容。
先实现一个死循环，提供模拟的update：
```csharp
static void Main(string[] args) {
List<MonoBehaviour> monoBehaviours = new List<MonoBehaviour>();
monoBehaviours.Add(new MyGameObject()); // 模拟一个MonoBehaviour
while (true) {
// 模拟游戏循环
foreach (var item in monoBehaviours)
{
item.Update(); // 简易模拟update
item.UpdateOver(); // 在这里处理协程相关内容
}
Thread.Sleep(16); // 假装过了一帧 16ms
}
}
```
再提供一个假的MonoBehaviour
```csharp
class MonoBehaviour {
public MonoBehaviour() { Awake(); }
// 存储所有的协程，用于遍历以及停止
private HashSet<Coroutine> coroutines = new HashSet<Coroutine>();
public Coroutine StartCoroutine(IEnumerator routine) {
Coroutine coroutine = new Coroutine();
coroutine.Add(routine);
coroutines.Add(coroutine);
return coroutine;
}
// 停止一个协程，本质上是将其移除， 后续就不会再触发了
public void StopCoroutine(Coroutine routine) {
coroutines.Remove(routine);
}
virtual public void Awake() {}
virtual public void Update() {}
virtual public void UpdateOver() {
List<Coroutine> cors = new List<Coroutine>(coroutines);
foreach (var item in cors) {
if (item.MoveNext()) // 将协程（迭代器）迭代一次
Console.WriteLine($"\t {item.Current}"); // 打印下当前对象
else
coroutines.Remove(item); // 协程结束
}
}
}
```
上面的Coroutine主要维护了保留当前迭代器器的信息，个人认为本质上也是一个迭代器。 实现如下：
```csharp
class Coroutine : IEnumerator {
// 使用栈来存储当前运行的迭代器
private Stack<IEnumerator> stack = new Stack<IEnumerator>();
public void Add(IEnumerator enumerator) {
stack.Push(enumerator);
}
public object Current // 获取当前对象，
{
get
{
if (stack.Count == 0) return null;
return stack.Peek();
}
}
// 迭代器迭代一次
public bool MoveNext() {
while (stack.Count > 0) {
IEnumerator enumerator = stack.Peek();
if (enumerator.MoveNext()) {
if (enumerator.Current is IEnumerator) {
// 如果是嵌套的迭代器，那么就入栈，依次进行迭代
Add((IEnumerator)enumerator.Current);// 开启嵌套的协程
}
// 其他类型的都等下一帧再次进行迭代
return true;
}
stack.Pop();
}
return false; // 当迭代完所有的迭代器后则认为结束，不能再移动到下一步
}
public void Reset() { }
}
```
框架以及搭好了，那么实现一个简单实现一个 WairForSeconds：
```csharp
class WairForSeconds : IEnumerator {
private float seconds;
private bool start = false;
private long timeStamp;
public WairForSeconds(float seconds) {
this.seconds = seconds;
}
public object Current => this;
public bool MoveNext() {
if (start == false) {
start = true;
timeStamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
}
if (DateTimeOffset.UtcNow.ToUnixTimeSeconds() - timeStamp >= seconds) {
return false;
}
return true;
}
public void Reset() { }
}
```
测试代码如下：
```csharp
class MyGameObject : MonoBehaviour
{
private int updateCount = 0;
Coroutine coroutine;
public override void Awake()
{
Console.WriteLine("Update start");
coroutine = StartCoroutine(DoCoroutine());
Console.WriteLine("Update end");
}
public override void Update()
{
updateCount++;
if (updateCount == 10)
{
StopCoroutine(coroutine);
Console.WriteLine("协程被停止了");
}
}
IEnumerator DoCoroutine()
{
Console.WriteLine($"{DateTime.Now} DoCoroutine start");
yield return null; // 暂停协程等待下一帧继续执行
Console.WriteLine($"{DateTime.Now} DoCoroutine 111111111111");
yield return 1; // 或其他数字 暂停协程等待下一帧继续执行
Console.WriteLine($"{DateTime.Now} DoCoroutine 222222222222");
yield return new WairForSeconds(1); // 等待规定时间后继续执行
Console.WriteLine($"{DateTime.Now} DoCoroutine 333333333333");
yield return DoCoroutine1();
Console.WriteLine($"{DateTime.Now} DoCoroutine 444444444444");
}
IEnumerator DoCoroutine1()
{
yield return 1;
yield return 2;
yield return 3;
}
}
```
执行结果如下：
!(data/attachment/forum/202304/23/003651tc2xyzx1bsriy8z9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "5d6b81091e0149be806597d2aae47310.png")
参考
https://zhuanlan.zhihu.com/p/355377979
Unity 协程原理探究与实现. 感觉这篇实现复杂了。
页:
[1]