多线程工具类

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

/// <summary>
/// 多线程工具类
/// </summary>
public class Wolker : IDisposable
{
    //存放所有的调试对象
    List<Thread> mAllThreads = new List<Thread>();
    //任务队列
    private Queue<ThreadHandlers> mTaskQueue = new Queue<ThreadHandlers>();
    //任务处理器
    private ITaskCollector mTaskCollector;

    //标记是否已经销毁
    private bool mDisposed = false;

    /// <summary>
    /// 线程上下文
    /// </summary>
    public class ThreadContext
    {
        public int ID = -1;
    }

    public Wolker(ITaskCollector task)
    {
        mTaskCollector = task;
    }

    /// <summary>
    /// 添加任务
    /// </summary>
    /// <param name="task">任务</param>
    public void AddTask(ThreadHandlers task)
    {
        SetUp();
        lock (this)
        {
            mTaskQueue.Enqueue(task);
        }
    }

    /// <summary>
    /// 启动（初始化）
    /// </summary>
    public Wolker SetUp(int maxThreads = 4)
    {
        if (mAllThreads.Count == 0)
        {
            ParameterizedThreadStart mOnRun = OnRun;
            for (int i = 0; i < maxThreads; i++)
            {
                var thread = new Thread(mOnRun);
                mAllThreads.Add(thread);
                var context = new ThreadContext();
                context.ID = i; //记录Id，方便调试
                thread.IsBackground = true;
                thread.Start(context);
            }
        }
        return this;
    }

    /// <summary>
    /// 销毁资源
    /// </summary>
    public void Dispose()
    {
        if (mDisposed) return;
        mDisposed = true;
        mAllThreads.Clear();
        mTaskCollector = null;
    }

    /// <summary>
    /// 线程处理函数
    /// </summary>
    /// <param name="obj"></param>
    void OnRun(object obj)
    {
        ThreadContext context = obj as ThreadContext;
        while (!mDisposed)
        {
            ThreadHandlers task = null;
            lock (this)
            {
                if (mTaskQueue.Count > 0)
                {
                    task = mTaskQueue.Dequeue();
                }
            }

            if (task == null)
            {
                Thread.Sleep(10);
            }
            else
            {
                task.OnRun();
                if (mTaskCollector != null)
                {
                    mTaskCollector.Append(task);
                }
            }
        }
    }
}


public interface ITaskCollector
{
    /// <summary>
    /// 将handler丢给主线程
    /// </summary>
    /// <param name="handler"></param>
    void Append(ThreadHandlers handler);
}

/// <summary>
/// 任务收集器，当子线程处理结束后会放到这里回调
/// </summary>
public sealed class TaskCollector : List<ThreadHandlers>, ITaskCollector
{
    private List<ThreadHandlers> mTmp = new List<ThreadHandlers>();

    public void Append(ThreadHandlers handler)
    {
        lock (this)
        {
            Add(handler);
        }
    }

    public void Invoke()
    {
        lock (this)   //这里只是拷贝指针，所以耗时比较短
        {
            for (int i = 0, n = mTmp.Count; i < n; i++)
            {
                mTmp.Add(this[i]);
            }
            Clear();
        }

        //这里执行函数处理，比较耗时，不能放到锁里面
        for (int i = 0, n = mTmp.Count; i < n; i++)
        {
            var it = mTmp[i];
            it.OnFinished();
            it.OnRelease();
        }
    }
}


/// <summary>
/// 线程处理对象
/// </summary>
public class ThreadHandlers
{
    /// <summary>
    /// 上下文信息
    /// </summary>
    public object mContext = null;

    public virtual void OnRelease() { }

    /// <summary>
    /// 线程处理函数
    /// </summary>
    public virtual void OnRun() { }

    public virtual void OnFinished() { }
}