Unity3D -Thread多线程,Queue队列,lock关键字

我就是我 2023-01-08 04:29 188阅读 0赞

# 例一： #

1.Thread  多线程

Unity里一般用于Socket连接，开一条线程接消息。

2.Queue 队列

对象的先进先出集合，可以规定特定类型的队列集合，也可以什么类型都存入队列。

Queue aaa = new Queue();   Queue<int> aaa = new Queue<int>(); 都是可以的。

3.lock 关键字

主要用于处理并发问题、锁定独占对象。锁定的必须是引用类型！

先写一个线程类，不用继承MonoBehaviour。

public class XianCheng
    {
     
        public Thread ThreadOne;
        public Thread ThreadTwo;
     
        public Queue<int> queue = new Queue<int>(); //先进先出队列
     
        public void StartXianCheng()
        {
     
            //线程1
            ThreadOne = new Thread(Count);       //线程开始方法
            ThreadOne.IsBackground = true;       //后台线程会随着主线程结束退出
          //ThreadOne.Name = "Xiancheng1";       //线程名字
            ThreadOne.Start();                   //开始线程
     
            //线程2
            ThreadTwo = new Thread(Count);
            ThreadTwo.Start();
     
        }
     
     
        public void Count()
        {
                                                  //这里可以注释掉lock来测试
                lock (queue)                      //锁定队列，必须等待一条线程访问完成后，别的线程才能使用
                {
                    queue.Enqueue(1);             //入队
                 // queue.Dequeue();              //出队，返回队列开始处的对象，并且删除它！
     
     
                    Thread.Sleep(1000);           //线程休眠毫秒数
                 // ThreadOne.Suspend();          //暂停线程
                 // ThreadOne.Resume();           //继续线程
     
                }
         }
     
    }

再写一个类，很简单。

public class NewBehaviourScript : MonoBehaviour {
     
        XianCheng xiancheng;
     
    	void Start () {
            xiancheng = new XianCheng();
            xiancheng.StartXianCheng();
    	}
    	
     
    	void Update () {
             Debug.Log(xiancheng.queue.Count);  //lock的话，打印先1后2，不lock直接2，因为两个线程同时使用了队列。
    	}
     
        
        void OnApplicationQuit()
        {
           xiancheng.ThreadTwo.Abort();               //终止线程1
           xiancheng.ThreadOne.Abort();               //终止线程2
        }
    }

# 例二： #

using UnityEngine;
    using System.Collections;
    using UnityEngine.UI;
    
    public class QueueExample : MonoBehaviour
    {
        public Queue queue;
        public Text queueCount;
        public Text queueContent;
        public Text queuePeek;
    
        void Start()
        {
            queue = new Queue();
        }
    
        void Update()
        {
            if (queue.Count > 0)
            {
                queuePeek.text = "queuePeek : " + queue.Peek().ToString();
            }
            else
            {
                queuePeek.text = "queuePeek : ";
            }
    
            //增加元素
            if (Input.GetKeyDown(KeyCode.A))
            {
                InsetTime();
                showQueue();
            }
    
            //减去元素
            if (Input.GetKeyDown(KeyCode.D))
            {
                if (queue.Count > 0)
                {
                    Debug.Log(queue.Dequeue());
                    showQueue();
                }
            }
    
            //清除队列所有元素
            if (Input.GetKeyDown(KeyCode.C))
            {
                queue.Clear();
                showQueue();
            }
    
            queueCount.text = "queueCount : " + queue.Count.ToString();
        }
    
        void InsetTime()
        {
            queue.Enqueue(Time.time);
        }
    
        void showQueue()
        {
            queueContent.text = "queueContent : ";
            foreach (float value in queue)
            {
                queueContent.text += value.ToString() + " | ";
            }
        }
    }

# 例三： #

//用平均值的方法平滑陀螺仪曲线，实现思想简单描述如下
    Queue<Quaternion> averageList;
    averageList.Enqueue (Input.gyro.attitude);
    if (averageList.Count > 240)
    averageList.Dequeue ();
    foreach (Quaternion singleRotation in averageList)
    {
    //分离，重组Quaternion，获得平均值averageRotation
    }
    //通过插值贴回给摄像头
    transform.localRotation = Quaternion.Slerp(transform.localRotation, averageRotation, Time.deltaTime* 4f);

Queue的基本功能有插入、提取和检查操作。可以用来如排队，计时等线性相关的问题。 通过插入，提取，检查，清除等操作了解queue的运行，

using UnityEngine;
    using System.Collections;
    using UnityEngine.UI;
     
    public class QueueExample : MonoBehaviour
    {
        public Queue queue;
        public Text queueCount;
        public Text queueContent;
        public Text queuePeek;
     
        void Start()
        {
            queue = new Queue();
        }
     
        void Update()
        {
            if (queue.Count > 0)
            {
                queuePeek.text = "queuePeek : " + queue.Peek().ToString();
            }
            else
            {
                queuePeek.text = "queuePeek : ";
            }
     
            //增加元素
            if (Input.GetKeyDown(KeyCode.A))
            {
                InsetTime();
                showQueue();
            }
     
            //减去元素
            if (Input.GetKeyDown(KeyCode.D))
            {
                if (queue.Count > 0)
                {
                    Debug.Log(queue.Dequeue());
                    showQueue();
                }
            }
     
            //清除队列所有元素
            if (Input.GetKeyDown(KeyCode.C))
            {
                queue.Clear();
                showQueue();
            }
     
            queueCount.text = "queueCount : " + queue.Count.ToString();
        }
     
        void InsetTime()
        {
            queue.Enqueue(Time.time);
        }
     
        void showQueue()
        {
            queueContent.text = "queueContent : ";
            foreach (float value in queue)
            {
                queueContent.text += value.ToString() + " | ";
            }
        }
    }

例四：消息广播中心

using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.Events;
    using System;
    
    public class GameEvent{ }
    
    public class EventQueueSystem : MonoSingleton<EventQueueSystem>
    {
        public delegate void EventDelegate<T>(T e) where T : GameEvent;
    
        private delegate void InternalEventDelegate(GameEvent e);
    
        private Dictionary<Type, InternalEventDelegate> delegates = new Dictionary<Type, InternalEventDelegate>();
        private Dictionary<Delegate, InternalEventDelegate> delegateLookup = new Dictionary<Delegate, InternalEventDelegate>();
        private Dictionary<InternalEventDelegate, Delegate> delegateLookOnce = new Dictionary<InternalEventDelegate, Delegate>();
    
        private Queue eventQueue = new Queue();
    
        public bool bLimitQueueProcessing = false;
        public float limitQueueTime = 0.1f;
    
        //注册侦听事件（持续）
        public static void AddListener<T>(EventDelegate<T> del) where T : GameEvent
        {
            Instance.AddDelegate(del);
        }
    
        //注册侦听事件（一次）
        public static void AddListenerOnce<T>(EventDelegate<T> del) where T : GameEvent
        {
            var result = Instance.AddDelegate(del);
            if (result != null)
                Instance.delegateLookOnce[result] = del;
        }
    
        //判定侦听事件是否存在
        public static bool HasListener<T>(EventDelegate<T> del) where T : GameEvent
        {
            return Instance.delegateLookup.ContainsKey(del);
        }
    
        //移除侦听事件
        public static void RemoveListener<T>(EventDelegate<T> del) where T : GameEvent
        {
            if (Instance == null)
                return;
            if (Instance.delegateLookup.TryGetValue(del, out InternalEventDelegate eventDelegate))
            {
                if (Instance.delegates.TryGetValue(typeof(T), out InternalEventDelegate temp))
                {
                    temp -= eventDelegate;
                    if (temp == null)
                        Instance.delegates.Remove(typeof(T));
                    else
                        Instance.delegates[typeof(T)] = temp;
                }
                Instance.delegateLookup.Remove(del);
            }
        }
    
        public static void RemoveAll()
        {
            if (Instance != null)
            {
                Instance.delegates.Clear();
                Instance.delegateLookup.Clear();
                Instance.delegateLookOnce.Clear();
            }
        }
    
        private InternalEventDelegate AddDelegate<T>(EventDelegate<T> del) where T : GameEvent
        {
            if (delegateLookup.ContainsKey(del))
                return null;
            void eventDelegate(GameEvent e) => del((T)e);
            delegateLookup[del] = eventDelegate;
    
            if (delegates.TryGetValue(typeof(T), out InternalEventDelegate temp))
                delegates[typeof(T)] = temp += eventDelegate;
            else
                delegates[typeof(T)] = eventDelegate;
            return eventDelegate;
        }
    
        //单个事件触发
        private static void TriggerEvent(GameEvent e)
        {
            var type = e.GetType();
            if(Instance.delegates.TryGetValue(type,out InternalEventDelegate eventDelegate))
            {
                eventDelegate.Invoke(e);
                //移除单一侦听
                foreach(InternalEventDelegate item in Instance.delegates[type].GetInvocationList())
                {
                    if (Instance.delegateLookOnce.TryGetValue(item,out Delegate temp))
                    {
                        Instance.delegates[type] -= item;
                        if (Instance.delegates[type] == null)
                            Instance.delegates.Remove(type);
                        Instance.delegateLookup.Remove(temp);
                        Instance.delegateLookOnce.Remove(item);
                    }
                }
            }
        }
    
        //外部调用的推入事件队列接口
        public static void QueueEvent(GameEvent e)
        {
            if (!Instance.delegates.ContainsKey(e.GetType()))
                return;
            Instance.eventQueue.Enqueue(e);
        }
    
        //事件队列触发处理
        void Update()
        {
            float timer = 0.0f;
            while (eventQueue.Count > 0)
            {
                if (bLimitQueueProcessing)
                    if (timer > limitQueueTime)
                        return;
                var e = eventQueue.Dequeue() as GameEvent;
                TriggerEvent(e);
                if (bLimitQueueProcessing)
                    timer += Time.deltaTime;
            }
        }
    
        private void OnApplicationQuit()
        {
            RemoveAll();
            eventQueue.Clear();
        }
    }

[https://blog.csdn.net/u012322710/article/details/52885756][https_blog.csdn.net_u012322710_article_details_52885756]

[https://www.cnblogs.com/koshio0219/p/11209191.html][https_www.cnblogs.com_koshio0219_p_11209191.html]

[https_blog.csdn.net_u012322710_article_details_52885756]: https://blog.csdn.net/u012322710/article/details/52885756
[https_www.cnblogs.com_koshio0219_p_11209191.html]: https://www.cnblogs.com/koshio0219/p/11209191.html