如何在另一个线程中运行循环中的方法

Question

我有一个名为Update 的方法，它是从for(; ;) 循环中调用的，
在该方法中，我有另一个循环遍历列表的 for 循环，

for (int i = 0;i<LIST.Count;i++) { /* Code */ }

在那个循环中，我调用了一个方法，如果它运行会减慢进程（~250 FPS 到 ~55 FPS）。
如果我这样做了

for (int i = 0;i<LIST.Count;i++) { new Thread(() => /* Method */ ).Start(); }

它用尽了所有线程并且进程崩溃了。我如何在不使用所有线程的情况下运行该方法。

重要
我在System 中几乎不能使用任何东西。

Answer 1

可以使用一个小的帮助类/帮助线程来限制活动线程的数量，该帮助类/辅助线程管理多少线程同时处于活动状态并像这样使用它

for (var i = 0; i < list.Count; i++)
{
    var iterator = i;//note the iterator in a for loop isn't declared inside it's inner scope and will change on increment, similar also for foreach
    threadHelper.AddAction(() => { /* do stuff */ });

}
/* some more code that dont need the results of the threads*/

threadHelper.WaitForEnd();

之前没有使用纯线程类，之前只对任务做了类似的事情，它可能需要一些剧烈的优化，但我的幼稚方法是这样的

public class ThreadHelper
{
    private Thread[] Threads;
    private Thread CheckThread;
    private Queue<Action> Actions = new Queue<Action>();
    private int UpdateSpeed;
    public int RunnignThreads = 0;
    public bool Completed => RunnignThreads == 0 && !Actions.Any();



       public ThreadHelper(int maxThreads, int updateSpeed)
        {
            Threads = new Thread[maxThreads];
            UpdateSpeed = updateSpeed;
            // small thread to check if new actions should be executed
            CheckThread = new Thread(() =>
            {
                while (true)
                {
                    for (var i = 0; i < Threads.Length; i++)
                    {
                        //remove completed threads
                        if (!(Threads[i]?.IsAlive ?? true))
                        {
                            RunnignThreads--;
                            Threads[i] = null;
                        }
                        //add new
                        lock (Actions)
                        {
                            if (Threads[i] == null && Actions.Any())
                            {
    
                                var threadAction = Actions.Dequeue();
                                Threads[i] = new Thread(() => threadAction());
                                Threads[i].Start();
                                RunnignThreads++;
                            }
    
                        }
    
                    }
                    // just a small delay to 
                    Thread.Sleep(updateSpeed);
                }
            });
            CheckThread.Start();
        }

        ~ThreadHelper()
        {
            CheckThread.Abort();
        }
    
        public void AddAction(Action action)
        {
            lock (Actions)
            {
                Actions.Enqueue(action);
            }
        }
        //Maybe the waiting is a little bit trickier...
        public void WaitForEnd()
        {
            Thread.Sleep(UpdateSpeed *2 ); //maybe no threads are even startet before this gets called
            while (!Completed)
            {
                Thread.Sleep(UpdateSpeed);
            }
        }
    }