Unity 使用Loom插件实现主线程与C#线程之间的切换

关注

原创最新推荐文章于 2026-08-08 09:50:10 发布 3.1k 阅读 AI 写同款· GEO 优化 ›

Unity多线程安全实践：从Thread红线到Loom插件进阶 Unity多线程并非禁止使用，而是严格限定安全边界——子线程可执行纯CPU计算，但禁止调用任何Unity引擎API（如transform、Time、Resources等），否则触发InvalidOperationException或未定义行为。其原理源于Unity主线程承载渲染、物理、生命周期等多重调度职责，所有MonoBehaviour回调和引擎对象访问均强制绑定主线程。技术价值在于解耦耗时任务与帧率瓶颈，显著提升资源加载、算法计算、网络请求和大数据处理的响应性。典型应用场景包括异步纹理加载、后台路径寻路阅读详情

Loom代码如下：

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;
using System.Threading;
using System.Linq;

public class Loom : MonoBehaviour
{
    public static int maxThreads = 8;
    static int numThreads;
    private static Loom _current;
    private int _count;
    public static Loom Current
    {
        get
        {
            Initialize();
            return _current;
        }
    }

    void Awake()
    {
        _current = this;
        initialized = true;
    }
    static bool initialized;

    static void Initialize()
    {
        if ( !initialized )
        {

            if ( !Application.isPlaying )
                return;
            initialized = true;
            var g = new GameObject("Loom");
            _current = g.AddComponent<Loom>();
        }
    }

    private List<Action> _actions = new List<Action>();
    public struct DelayedQueueItem
    {
        public float time;
        public Action action;
    }
    private List<DelayedQueueItem> _delayed = new List<DelayedQueueItem>();

    List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();

    public static  void QueueOnMainThread(Action action)
    {
        QueueOnMainThread(action, 0f);
    }
    public static void QueueOnMainThread(Action action, float time)
    {
        if ( time != 0 )
        {
            lock ( Current._delayed )
            {
                Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = action });
            }
        }
        else
        {
            lock ( Current._actions )
            {
                Current._actions.Add(action);
            }
        }
    }

    public static Thread RunAsync(Action a)
    {
        Initialize();
        while ( numThreads >= maxThreads )
        {
            Thread.Sleep(1);
        }
        Interlocked.Increment(ref numThreads);
        ThreadPool.QueueUserWorkItem(RunAction, a);
        return null;
    }
    private static void RunAction(object action)
    {
        try
        {
            ((Action)action)();
        }
        catch
        {
        }
        finally
        {
            Interlocked.Decrement(ref numThreads);
        }

    }

    void OnDisable()
    {
        if ( _current == this )
        {

            _current = null;
        }
    }

    // Use this for initialization
    void Start()
    {

    }

    List<Action> _currentActions = new List<Action>();

    // Update is called once per frame
    void Update()
    {
        lock ( _actions )
        {
            _currentActions.Clear();
            _currentActions.AddRange(_actions);
            _actions.Clear();
        }
        foreach ( var a in _currentActions )
        {
            a();
        }
        lock ( _delayed )
        {
            _currentDelayed.Clear();
            _currentDelayed.AddRange(_delayed.Where(d => d.time <= Time.time));
            foreach ( var item in _currentDelayed )
                _delayed.Remove(item);
        }
        foreach ( var delayed in _currentDelayed )
        {
            delayed.action();
        }
    }
}

其中主要使用Loom中的两个函数：

 Loom.QueueOnMainThread(() => {//切换为主线程
              //todo 主线程的something
            });
            
 Loom.RunAsync(() =>{//切换为C#线程               
               //todo C#线程的something
            });

在需要切换线程时候调用两个方法即可。

收录于