Unity笔记：协程

最新推荐文章于 2024-07-02 21:13:10 发布
最新推荐文章于 2024-07-02 21:13:10 发布
阅读量1.7k 收藏 25
点赞数 26
分类专栏： Unity 文章标签： unity 笔记 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39377889/article/details/136531455
版权

协程

协程有IEnumerator类型返回值，所以总要有至少一个yield return xxx

基础入门直接看这个就够了：gamedevbeginner - Unity 中的协程（如何以及何时使用它们）

考虑使用协程的典型情况：

  • 将对象移动到某个位置。
  • 为对象提供要执行的任务列表（如前面的待办事项列表示例中所示）。
  • 淡入淡出的视觉或音频。
  • 等待资源加载。

协程的特点：

  1. 无法显式检查协程是否已在运行
  2. 协程的执行持续的时间是不确定的。协程允许开发者在多个帧上执行游戏逻辑（这里就涉及到Unity如何依靠IEnumerator将协程拆分成多个帧执行）
  3. 协程的执行顺序也是不确定的，它是由Unity引擎控制的，它可能会在主循环的不同阶段执行。

在Unity中，协程的执行是由Unity引擎来管理的。当你启动一个协程时，Unity会在后台为该协程创建一个迭代器（iterator，这要求协程的返回值是IEnumerator），并在每一帧中逐步执行该迭代器。

  1. 按顺序执行：Unity会按照协程启动的顺序来执行它们。如果有多个协程在同一帧启动，它们将按照启动的顺序进行排列执行。
  2. 帧更新执行：协程的执行是在Unity的每一帧更新中进行的。每当Unity引擎执行一帧时，它会检查当前正在执行的所有协程，并根据协程的当前状态来决定是否继续执行、暂停执行或者完成执行。
  3. 暂停和继续：当协程执行到 yield return 语句时，Unity引擎会暂停该协程的执行，并将执行控制权交还给引擎。在等待的条件满足或者时间间隔过去后，Unity引擎会重新激活协程，并从 yield return 语句之后的代码开始继续执行。
  4. 时间管理：当协程使用 yield return new WaitForSeconds(time) 等待一段时间时，Unity引擎会在等待时间结束后再次激活该协程。这样可以确保协程在指定的时间间隔后再次执行。
  5. 性能优化：虽然协程可以在多个帧中执行，但过多的协程同时执行也可能会影响性能。因此，在使用协程时应注意控制协程的数量，避免不必要的性能消耗。

协程的启动

  1. 以字符串传入协程名字启动
  2. 直接传递协程方法的引用

这种方法必须要求协程和启动写在一个文件里。如果不在一个文件里，Unity会在当前对象所附加的脚本中查找对应的协程方法，并且启动方法只能是直接传递协程方法的引用

注：当使用字符串启动协程时，只能传入一个参数

// 以字符串传入协程名字启动
StartCoroutine("MyCoroutine");
// 以字符串传入协程名字启动最多一个参数
StartCoroutine("MyCoroutine", 1);
IEnumerator MyCoroutine(int value)
{
    // Code goes here...
}
// 直接传递协程方法的引用
StartCoroutine(MyCoroutine());
// 传递协程方法的引用在别的脚本
StartCoroutine(OtherScriptName.MyCoroutine());

协程与yield

任何协程暂停的代码都需要从yield return开始，yield 表示该方法是一个迭代器，它将在多个帧上执行，而 return 与常规函数一样，在该点终止执行并将控制权传递回调用方法。不同之处在于，使用协程时，Unity 知道从中断的地方继续该方法。yield return 后面的内容将指定 Unity 在继续之前等待多长时间。

等待到下一帧再执行

通过yield return null通常可以实现帧计数：

IEnumerator MyCoroutine()
{
    // 执行一些操作
    yield return null; // 暂停协程，等待下一帧
    // 在暂停之后是从这里继续执行
}

等待一定时间

暂停协程的执行一段时间，然后在指定的时间后继续执行。

IEnumerator MyCoroutine()
{
    // 执行一些操作
    yield return new WaitForSeconds(2.0f); // 暂停协程，等待2秒
    // 继续执行
}

如果要反复delay（如在while中），缓存 WaitforSeconds 对象的性能会稍好一些。

WaitForSeconds delay = new WaitForSeconds(1);

而WaitForSecondsRealtime(5);会在游戏暂停也执行，这是和WaitForSeconds在游戏暂停时等待时间不流逝是不一样的

等待帧结束

这个用法会暂停协程的执行直到当前帧结束后继续执行。通常用于在当前帧渲染完成后执行一些操作，典型用途是截取屏幕截图。

IEnumerator MyCoroutine()
{
    // 执行一些操作
    yield return new WaitForEndOfFrame(); // 暂停协程，等待当前帧结束
    // 继续执行
}

等待某bool表达式为true

下面这个则是等待值为true才执行后面的

IEnumerator CheckFuel()
{
    yield return new WaitWhile(() => fuel > 0);
    print("tank is empty");
}

等待另一个协程执行完

IEnumerator MyCoroutine()
{
    print("Coroutine has started");
    yield return StartCoroutine(MyOtherCoroutine());
    // 在启动的协程完成后，代码将继续
    print("Coroutine has ended");
}

什么情况需要使用在当前帧结束完执行协程？主要是那些避免影响游戏性能和用户体验的场景：

  1. UI更新：有时你可能需要等待当前帧渲染完成后再更新UI，以确保UI元素在渲染前已经准备就绪，避免出现闪烁或不良的渲染效果。（那为什么不放在LateUpdate呢？）
  2. 延迟加载资源：在某些情况下，可能需要在当前帧结束后加载资源，以确保不影响当前帧的性能。例如，当某些资源仅在某些条件下才需要加载时，可以在下一帧加载这些资源，而不是立即加载。
  3. 执行复杂计算：如果有复杂的计算或处理需要在游戏逻辑更新之后执行，可以将这些操作放入协程中，在下一帧执行，以避免影响当前帧的性能。
  4. 网络请求或数据库操作：当需要进行网络请求或数据库操作时，可能需要等待当前帧结束后再执行，以避免阻塞主线程，从而提高游戏的流畅性和响应性。
  5. 场景切换后的操作：在场景切换后，可能需要进行一些初始化或清理操作，这些操作最好在当前帧结束后执行，以确保场景切换的流畅性和正确性。

yield的特殊情况

IEnumerator FetchData()
    {
        Todo[] todos;
        User[] users;
        // USERS
        var www = new WWW(USERS_URL);
        yield return www;
        if (!string.IsNullOrEmpty(www.error))
        {
            Debug.Log("An error occurred");
            yield break;
        }
        var json = www.text;
        try
        {
            var userRaws = JsonHelper.getJsonArray<UserRaw>(json);
            users = userRaws.Select(userRaw => new User(userRaw)).ToArray();
        }
        catch
        {
            Debug.Log("An error occurred");
            yield break;
        }
        // TODOS
        www = new WWW(TODOS_URL);
        yield return www;
        if (!string.IsNullOrEmpty(www.error))
        {
            Debug.Log("An error occurred");
            yield break;
        }
        json = www.text;
        try
        {
            var todoRaws = JsonHelper.getJsonArray<TodoRaw>(json);
            todos = todoRaws.Select(todoRaw => new Todo(todoRaw)).ToArray();
        }
        catch
        {
            Debug.Log("An error occurred");
            yield break;
        }
        // OUTPUT
        foreach (User user in users)
        {
            Debug.Log(user.Name);
        }
        foreach (Todo todo in todos)
        {
            Debug.Log(todo.Title);
        }
    }
    void Start()
    {
        StartCoroutine(FetchData());
    }
}

注意这里可以yield return www是因为在Unity中，WWW类实现了IEnumerator接口，因此可以在协程中使用yield return来暂停协程的执行，直到网络请求完成。一旦请求完成，协程会继续执行下面的代码，完成数据的处理和输出。

协程的停止

协程在执行其代码后自动结束，无需显式结束

  1. 协程内部中断使用yield break
  2. 协程外部中断使用StopCoroutine("MyCoroutine");
  3. 停止 MonoBehaviour 上的所有协程StopAllCoroutines();

StopAllCoroutines();停止由调用它的脚本启动的所有协程，因此它不会影响在其他地方运行的其他协程，但是如果脚本 A 运行的协程启动了脚本B上的一个协程，那从脚本 A 调用StopAllCoroutines();会把这俩都关了，但是从脚本B上调用则一个也不会停止。

销毁或禁用游戏对象将终止从该对象调用的任何协程，也就是说存在一种情况是销毁了游戏对象A但是其上的协程没有终止，因为那个协程是由B调用启动的。

协程与Thread的区别

Unity的协程（Coroutine）和C#的线程（Thread）是用于实现异步操作的两种不同的机制

  • 如果要使用异步执行来表达游戏逻辑，请使用协程。
  • 如果要使用异步执行来利用多个 CPU 内核，请使用线程，但是在子线程不要接触任何Unity原生功能，因为它完全不知道 Unity 主循环目前处于什么状态

区别如下：

  1. 执行上下文：

    • 协程在 Unity 中是基于协程管理器（Coroutine Manager）的，运行在主线程中。因此，协程可以访问 Unity 的 API 和对象，但不能进行跨线程操作。
    • 线程是独立的执行线程，与主线程分离。线程可以在后台执行任务，允许进行耗时操作，但在访问 Unity 的 API 和对象时，需要使用线程安全的方式，例如通过主线程调用 UnityMainThreadDispatcher 或使用 UnityMainThreadDispatcher 等工具。

  2. 开销：

    • 协程相对于线程来说，开销较小。因为协程是基于迭代器的，不需要像线程那样创建和管理额外的线程。
    • 线程的创建和销毁需要更多的系统资源，因此在某些情况下，线程可能会导致更大的性能开销。

  3. 并发性：

    • 协程在 Unity 中是顺序执行的，并不能真正实现多线程并发。即使使用了多个协程，它们仍然是在主线程中按顺序执行的。
    • 线程是真正的并发执行机制，可以在多个线程上同时执行不同的任务。这使得线程更适合处理需要同时进行的耗时操作，如网络请求、文件IO等。

  4. 线程安全：

    • 协程可以直接访问 Unity 的对象和 API，因此不需要担心线程安全的问题。
    • 线程需要考虑线程安全的问题，需要使用锁、互斥量等机制来保护共享资源，以避免多线程同时访问导致的数据竞争和不确定性。

Unity 的 API 大部分是单线程访问的，这意味着在非主线程上直接访问 Unity 的 API 可能会导致异常或不确定的行为。如果没有特别需要，建议尽量避免在 Unity 中使用线程，而是使用协程等 Unity 提供的异步机制来处理异步操作。

协程更适合处理需要在多个更新周期中分批执行的任务，而线程更适合处理需要利用多核CPU的任务

协程、Invoke与Async

在Unity中，有几种常用的用于处理异步操作的方法：

  1. 协程（Coroutines）：协程是Unity中用于处理异步操作的一种技术，它允许在多帧中分解一个操作，以避免阻塞主线程。
  2. Invoke：一种用于延迟调用方法的方法。可以使用Invoke方法在一定时间后调用指定的方法。
  3. Async：C#中用于处理异步操作的关键字，通常与await一起使用。在Unity中，可以使用Async/Await来处理异步操作，比如网络请求、文件读写等。

Async 和 Await 函数与协程之间的最大区别之一是它们可以返回一个值，而通常协程不能这样做。

Unity Documentation - MonoBehaviour.Invoke

Medium - Unity: Leveling up with Async / Await / Tasks

关于Coroutines与Async：

  1. 旧版本Unity可能不支持C#的Async/Await特性
  2. 协程侧重于分帧处理，Async侧重于异步
Binarydog_Lee
关注
  • 26
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Toolkit for Unity Physics: Ballistics 3.2.0
06-12
Toolkit for Unity Physics: Ballistics,资源仅供学习，如有需求，请自行在商店购买：https://assetstore.unity.com/packages/tools/physics/toolkit-for-unity-physics-ballistics-251081
Unity的协程详解
热门推荐
vinkey_st的博客
09-08 2万+
协程，即为协同程序. Unity中的协程由协程函数和协程调度器两部分构成.协程函数使用的是C#的迭代器, 协程调度器则利用了MonoBehaviour中的生命周期函数来实现. 协程函数实现了分步, 协程调度器实现了分时.注：因为协程分时分步执行的特性，当多个协程的耗时操作挤在同一时间执行也会造成卡顿。
Unity——协程（Coroutine）
m0_63024355的博客
08-30 5170
本文为问GPT所得。
Unity之协程(Coroutine)
最新发布
m0_64163189的博客
07-02 434
协程与线程、进程不同，协程的上下文切换是由程序员决定的，在开启协程后可以暂停协程执行，暂停之后会返回主函数(开启协程所在的函数)，执行主函数剩余的部分，直到中断指令完成后，从中断指令的下一行继续执行协程函数的剩余部分，函数体执行完，协程即结束。yield return new WaitForSeconds(float time)//协程在延迟指定时间后且当前帧所有脚本的update全部执行完后才会继续执行 且当timescale=0,是不会执行。//当前帧所有Fixedupdate执行完后执行”
unity-协程详解
qq_52905520的博客
08-20 4535
unity协程详解
Unity中的协程
成长之路，任重道远，期待你的关注！
01-24 1788
在学习unity的过程中会遇到“协程”的概念，听到协程我们脑海里应该会想到它当然不是一个东西，两者可以说不相干，下面就讲一下什么是unity中的协程。我们先看下官网手册上是怎么说的：协程就像一个函数，能够暂停执行并将控制权返还给 Unity，然后在下一帧继续执行。没错，在Unity中，协程是一种特殊的函数，能够在其执行过程中暂停并在稍后恢复。与常规函数不同，协程允许你在执行过程中等待一段时间、等待某个条件满足或者在每一帧执行一些操作。Unity中的协程是一种处理时间、动画和异步操作的强大工具。
【Unity】Unity协程(Coroutine)的原理与应用
hafeiyangha的博客
06-20 6746
首先看一下Unity官方对协程的定义：Unity中的协程是一种返回值为的特殊函数，它可以主动的请求暂停自身并提交一个唤醒条件，Unity会在唤醒条件满足的时候去重新唤醒协程，所以协程还是运行在主线程上。
【Unity入门】协程(IEnumerator)的使用方法介绍
希望有志同道合的的朋友可以互相学习！
05-13 2123
协程在Unity中是一个很重要的概念，我们知道，在使用Unity进行游戏开发时，一般（注意是一般）不考虑多线程，那么如何处理一些在主任务之外的需求呢，Unity给我们提供了协程这种方式。为啥在Unity中一般不考虑多线程？因为在Unity中，只能在主线程中获取物体的组件、方法、对象，如果脱离这些，Unity的很多功能无法实现，那么多线程的存在与否意义就不大了。线程与协程有什么区别？对于协程而言，同一时间只能执行一个协程，而线程则是并发的，可以同时有多个线程在运行。
Unity插件：Odin
07-01
Unity编辑器扩展插件，可以实现更加强大的序列化特性
unity通过协程实现异步下载数据并加载
08-21
为了不阻塞游戏主循环，Unity3D引入了协程（Coroutine）的概念，允许开发者以非阻塞的方式处理长时间运行的任务，比如下载和加载资源。 **协程简介** 协程是一种轻量级的线程，它不像传统的多线程那样需要频繁地上...
unity笔记 全阶段
03-16
【Unity 全阶段学习笔记】 Unity 是一款强大的跨平台游戏引擎，被广泛应用于游戏开发、虚拟现实、增强现实以及各种互动体验的制作。本笔记旨在为初学者提供一个全面的Unity学习路径，从基础到进阶，涵盖环境搭建、...
unity开发：基础知识介绍
05-01
unity开发：基础知识介绍
Unity3d协程实现
10-15
Unity3D是一款强大的跨平台游戏开发引擎，而协程（Coroutine）是Unity中一个非常重要的概念，它允许开发者在执行过程中暂停和恢复一个函数，而不是一次性执行完毕。这对于实现复杂的逻辑，如动画过渡、延时操作、...
unity 协程详细说明 demo
02-26
unity 协程详细说明。具体教程http://blog.csdn.net/fengya1/article/details/79380410
C#迭代器及Unity协程实例解析
08-19
C#迭代器及Unity协程实例解析 C#迭代器是指在C#语言中实现的迭代器接口，主要用于遍历集合类对象。它主要包含两个接口：IEnumerable和IEnumerator。IEnumerable接口定义了一个GetEnumerator()方法，用于获取...
Unity笔记资源大全
06-02
这份“Unity笔记资源大全”显然是一份全面的学习资料，涵盖了Unity的基础操作和重要概念，适合初学者入门或者有经验的开发者进行回顾。现在，我们将深入探讨其中可能包含的知识点。 1. **Unity界面与工作流程** - ...
[Unity3D] 协程
努力学习
04-19 695
学习笔记，仅供学习，不做商用，如有侵权，联系我删除即可协程就像一个函数，能够暂停执行并将控制权返还给 Unity，然后在下一帧继续执行。协程本质上是一个用返回类型 IEnumerator 声明的函数，并在主体中的某个位置包含 yield return 语句。yield 的所在行是暂停执行并随后在下一帧恢复的点。
unity，通俗解释什么是协程
qq_20179331的博客
04-04 1262
在Unity中，协程是一种轻量级的线程，可以在同一线程中执行多个任务，实现异步等待和延迟执行等效果。协程的执行是基于迭代器的，可以通过yield语句来实现暂停和恢复执行，从而更加灵活地控制协程的执行过程。协程可以在不创建新线程的情况下实现异步等待和延迟执行，避免了线程切换和同步等问题，从而提高了程序的性能和效率。在Unity中，协程通常用于处理一些异步任务，比如等待一段时间、播放动画、加载资源等。
Unity3D--协程使用详解
weixin_45488182的博客
06-16 4310
Unity3D--协程使用详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值