微信登录

Loom.cs - 线程器 - 从子线程转到主线程

作用：从子线程转到主线程

第一步创建Loom.cs

  1. using UnityEngine;  
  2. using System.Collections;  
  3. using System.Collections.Generic;  
  4. using System;  
  5. using System.Threading;  
  6. using System.Linq;  
  8. public class Loom : MonoBehaviour  
  9. {  
  10.     public static int maxThreads = 8;  
  11.     static int numThreads;
  13.     private static Loom _current;
  14.     public static Loom Current  
  15.     {  
  16.         get  
  17.         {  
  18.             Initialize();  
  19.             return _current;  
  20.         }  
  21.     }  
  22.     //####去除Awake
  23. //  void Awake()  
  24. //  {  
  25. //      _current = this;  
  26. //      initialized = true;  
  27. //  }  
  29.     static bool initialized;  
  31.     //####作为初始化方法自己调用，可在初始化场景调用一次即可
  32.     public static void Initialize()  
  33.     {  
  34.         if (!initialized)  
  35.         {  
  37.             if(!Application.isPlaying)  
  38.                 return;  
  39.             initialized = true;  
  40.             GameObject g = new GameObject("Loom");  
  41.             //####永不销毁
  42.             DontDestroyOnLoad (g);
  43.             _current = g.AddComponent<Loom>();  
  44.         }  
  46.     }  
  48.     private List<Action> _actions = new List<Action>();  
  49.     public struct DelayedQueueItem  
  50.     {  
  51.         public float time;  
  52.         public Action action;  
  53.     }  
  54.     private List<DelayedQueueItem> _delayed = new  List<DelayedQueueItem>();  
  56.     List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();  
  58.     public static void QueueOnMainThread(Action action)  
  59.     {  
  60.         QueueOnMainThread( action, 0f);  
  61.     }  
  62.     public static void QueueOnMainThread(Action action, float time)  
  63.     {  
  64.         if(time != 0)  
  65.         {
  66.             if (Current != null)
  67.             {
  68.                 lock (Current._delayed)
  69.                 {
  70.                     Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = action });
  71.                 }
  72.             }
  73.         }  
  74.         else  
  75.         {
  76.             if (Current != null)
  77.             {
  78.                 lock (Current._actions)
  79.                 {
  80.                     Current._actions.Add(action);
  81.                 }
  82.             }
  83.         }  
  84.     }  
  86.     public static Thread RunAsync(Action a)  
  87.     {  
  88.         Initialize();  
  89.         while(numThreads >= maxThreads)  
  90.         {  
  91.             Thread.Sleep(1);  
  92.         }  
  93.         Interlocked.Increment(ref numThreads);  
  94.         ThreadPool.QueueUserWorkItem(RunAction, a);  
  95.         return null;  
  96.     }  
  98.     private static void RunAction(object action)  
  99.     {  
  100.         try  
  101.         {  
  102.             ((Action)action)();  
  103.         }  
  104.         catch  
  105.         {  
  106.         }  
  107.         finally  
  108.         {  
  109.             Interlocked.Decrement(ref numThreads);  
  110.         }  
  112.     }  
  115.     void OnDisable()  
  116.     {  
  117.         if (_current == this)  
  118.         {  
  120.             _current = null;  
  121.         }  
  122.     }  
  126.     // Use this for initialization  
  127.     void Start()  
  128.     {  
  130.     }  
  132.     List<Action> _currentActions = new List<Action>();  
  134.     // Update is called once per frame  
  135.     void Update()  
  136.     {  
  137.         lock (_actions)  
  138.         {  
  139.             _currentActions.Clear();  
  140.             _currentActions.AddRange(_actions);  
  141.             _actions.Clear();  
  142.         }  
  143.         foreach(var a in _currentActions)  
  144.         {  
  145.             a();  
  146.         }  
  147.         lock(_delayed)  
  148.         {  
  149.             _currentDelayed.Clear();  
  150.             _currentDelayed.AddRange(_delayed.Where(d=>d.time <= Time.time));  
  151.             foreach(var item in _currentDelayed)  
  152.                 _delayed.Remove(item);  
  153.         }  
  154.         foreach(var delayed in _currentDelayed)  
  155.         {  
  156.             delayed.action();  
  157.         }  
  161.     }  
  162. }

第二步：实例化

在GameFacade，初始化

  1. Loom.Initialize();//Loom线程控制初始化，把子线程调回主线程

第三步：使用

  1. Loom.QueueOnMainThread(do);//子线程回到主线程
  1.     public void do()
  2.     {
  3.           //各种例如换场景或调用UnityAPI
  4.     }

精彩教程

.bat程序教程
python入门基础教程
Pandas教程
Pygame教程
Django3.2.9教程
Flask1.1.1教程
python3.X - 区块链教程
Java教程
Spring教程
C#教程
PHP教程
R教程
Node.js教程
mysql数据库教程
Redis数据库教程
MongoDB数据库教程
RabbitMQ教程
Lua教程
FindBI教程
HTML5教程
CSS教程
Javascript教程
jQuery教程
微信小程序教程
微信小游戏教程
Vue.js教程
服务器教程
TensorFlow教程
PyTorch教程
Unity教程
Objective-C教程
Android教程
AppleScript教程
Mac - SHELL教程
算法教程
Python教程
数据库教程
运维工具教程
Nginx教程
Docker教程
Loom.cs - 线程器 - 从子线程转到主线程-书闪专业知识库