美文网首页
多线程接触

多线程接触

作者: 叫我颜先生 | 来源:发表于2019-07-17 15:49 被阅读0次

简介

自己开始接触一下多线程

Thread

  • 属性:主线程id为1,优先级Lowest,IsThreadPoolThread为false,IsBackground为false
  • 一个线程默认占用1M的堆栈空间,也可以修改
属性 说明
CurrentThreadManagedThreadId get 当前线程
Name get;set 线程名称
IsBackground get;set 是否为后台线程
IsThreadPoolThread get 是否属于托管线程池
ManagedThreadId get 当前托管线程唯一标识符
IsAlive 当前线程执行状态
Priority 当前线程调度优先级
ThreadState 当前线程的状态(运行停止后台禁止…)

方法:

方法 说明
Start 开启
Suspend 挂起
Resume 继续挂起的线程
Abort 终止
Sleep 当前线程挂起或阻塞指定时间

简单实例

  • 创建开始,有参函数参数只能有一个,而且是object类型,但是既然都是object了,就可以改变一下传更多参数

        void Start () {
    
            InitThread();
            Debug.LogError("MainThread:" + Thread.CurrentThread.ManagedThreadId.ToString());
        }
        
        private void InitThread()
        {
            Thread t1 = new Thread(Start1);
            t1.Start();
    
            Thread t2 = new Thread(Start2);
            t2.Start("LOG");
    
            Thread t3 = new Thread(Start3);
            t3.Start(new MoreParams(10086, "hah"));
        }
    
        private void Start1()
        {
            Debug.LogError("Start1:" + Thread.CurrentThread.ManagedThreadId.ToString());
        }
        
        //单个参数
        private void Start2(object log)
        {
            Debug.LogError("Start2:" + Thread.CurrentThread.ManagedThreadId.ToString()+log);
        }
        
        //多个参数
        private void Start3(object p)
        {
            MoreParams moreparams= (MoreParams)p;
            Debug.LogError("Start3:" + Thread.CurrentThread.ManagedThreadId.ToString());
            Debug.LogError("p1:" + moreparams.p1 + "_p2:" + moreparams.p2);
        }
    
        class MoreParams
        {
            public int p1;
            public string p2;
            public MoreParams(int p1, string p2)
            {
                this.p1 = p1;
                this.p2 = p2;
            }
        }
    

    输出:每次运行,主线程id为1,新线程的id都不同,会累加,输出顺序不固定

threadpool

方法 说明
GetMaxThreads(out workerThreads, out completePortsThreads) 线程池最大线程数,线程池异步IO最大线程数(默认我的60,30)
GetMinThreads 最小(默认我的4,4)
SetMaxTheads
SetMinThreads
QueueUserWorkItem 线程加入线程池,等待线程池调派执行
  • 线程完成任务不会自行销毁,而是挂起状态回到线程池

  • 向线程池发出请求时,挂起线程会再次激活

  • 线程池线程默认为后台线程

Loom

  • 在Update中不断检查需要回调的Action进行加锁回调,回调序列作为静态数据保存,可任意添加
  • 开启一个线程然后在Loom.RunAsyn()中调用需要回到Unity主线程更新界面时调用QueueOnMainThread()即可。简单好用。
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;
    private static int numThreads;

    private static Loom _current;
    //private int _count;
    public static Loom Current
    {
        get
        {
            Initialize();
            return _current;
        }
    }

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

    private static bool initialized;

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

            if (!Application.isPlaying)
                return;
            initialized = true;
            var g = new GameObject("Loom");
            _current = g.AddComponent<Loom>();
#if !ARTIST_BUILD
            UnityEngine.Object.DontDestroyOnLoad(g);
#endif
        }

    }
    public struct NoDelayedQueueItem
    {
        public Action<object> action;
        public object param;
    }

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

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

    public static Thread RunAsync(Action a)
    {
        Initialize();
        while (numThreads >= maxThreads)
        {
            Thread.Sleep(100);
        }
        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);
        }

    }

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

            _current = null;
        }
    }



    // Use this for initialization
    private void Start()
    {

    }

    private List<NoDelayedQueueItem> _currentActions = new List<NoDelayedQueueItem>();

    // Update is called once per frame
    private void Update()
    {
        if (_actions.Count > 0)
        {
            lock (_actions)
            {
                _currentActions.Clear();
                _currentActions.AddRange(_actions);
                _actions.Clear();
            }
            for (int i = 0; i < _currentActions.Count; i++)
            {
                _currentActions[i].action(_currentActions[i].param);
            }
        }

        if (_delayed.Count > 0)
        {
            lock (_delayed)
            {
                _currentDelayed.Clear();
                _currentDelayed.AddRange(_delayed.Where(d => d.time <= Time.time));
                for (int i = 0; i < _currentDelayed.Count; i++)
                {
                    _delayed.Remove(_currentDelayed[i]);
                }
            }

            for (int i = 0; i < _currentDelayed.Count; i++)
            {
                _currentDelayed[i].action(_currentDelayed[i].param);
            }
        }
    }
}

调用:

//创建线程
Loom.RunAsync(() => {
    Thread thread = new Thread(Start1);
    thread.Start();
});

//回调        
Loom.QueueOnMainThread((param) =>
{
    Debug.LogError("1");
}, null);  

相关文章

  • 多线程接触

    简介 自己开始接触一下多线程 Thread 属性:主线程id为1,优先级Lowest,IsThreadPoolTh...

  • 二、接触多线程

    开篇说明,有点基础,知道Thread,Runnable如何使用和两者之间的关系的可以直接跳过。 先说说Thread...

  • ios多线程的一些浅见

    前言 在移动端开发中不可避免的会接触到多线程。从用户使用体验角度来讲,也不可避免的会接触到多线程的操作。 多线程基...

  • Python之多线程开发

    以前我们接触的都是单线程单进程的python编程方式,从今天开始我们开始接触多线程和多进程的开发模式。首先多线程就...

  • 在 Java 中利用 redis 实现一个分布式锁服务

    在现代的编程语言中,接触过多线程编程的程序员多多少少对锁有一定的了解。简单的说,多线程中的锁就是在多线程环境下,多...

  • 在 Java 中利用 redis 实现一个分布式锁服务

    在现代的编程语言中,接触过多线程编程的程序员多多少少对锁有一定的了解。简单的说,多线程中的锁就是在多线程环境下,多...

  • Java 中利用 redis 实现一个分布式锁服务

    在现代的编程语言中,接触过多线程编程的程序员多多少少对锁有一定的了解。简单的说,多线程中的锁就是在多线程环境下,多...

  • 听故事学iOS系列 - 屎壳郎老板和它的收费公厕(一个故事搞懂多

    刚接触开发的童鞋,在学习多线程的时候,往往会比较吃力.因为这家伙比较抽象,有的时候较难通过运行代码直接看到多线程操...

  • 分享"一只爬虫"

    自接触爬虫以来,不管你有意识还是无意识都会不断的接触到这些概念:[多线程]、[多进程]、[协程]、[异步]... ...

  • 简析 Java 的线程池

    前言 从事编程的小伙伴们,必然是要接触多线程开发的,而常见的多线程应用程序不过是 new 一个线程(Thread)...

网友评论

      本文标题:多线程接触

      本文链接:https://www.haomeiwen.com/subject/nutxlctx.html