在线程内部使用ClearScript

Question

我有一个C＃应用程序，可以在其中生成多个线程。 我在.NET Framework 4.7.1上。 在这些线程中，执行工作，并且该工作可以执行用户定义的脚本功能。 我使用ClearScript作为脚本引擎，出于这个问题的目的，我使用VBScriptEngine。 这是一个演示我的问题的示例应用程序：

    static VBScriptEngine vbsengine = new VBScriptEngine();

    static void Main(string[] args)
    {
        for (int i=0;i<4000;i++)
        {
            Thread t = new Thread(Program.ThreadedFunc);
            t.Start(i);
        }
        Console.ReadKey();
    }

    static void ThreadedFunc(object i)
    {
        Console.WriteLine(i + ": " + vbsengine.Evaluate("1+1"));
    }

在Evaluate（）函数上，出现以下错误： System.InvalidOperationException： “调用线程无法访问此对象，因为其他线程拥有它。”

我了解ClearScript已实现了线程相似性，并且产生的线程无法访问全局定义的引擎。 那我有什么选择呢？ 为每个新线程创建一个新的ClearScript实例？ 这似乎非常浪费，并且会产生大量开销-我的应用程序将需要处理数千个线程。 我继续尝试了这种方法，尽管它确实起作用了（一段时间），但最终还是出错了。 这是我的示例应用程序的修订版：

    static void Main(string[] args)
    {
        for (int i=0;i<4000;i++)
        {
            Thread t = new Thread(Program.ThreadedFunc);
            t.Start(i);
        }
        Console.ReadKey();
    }

    static void ThreadedFunc(object i)
    {
        using (VBScriptEngine vbsengine = new VBScriptEngine())
        {
            Console.WriteLine(i + ": " + vbsengine.Evaluate("1+1"));
        }
    }

在新的VBScriptEngine（）调用上，我现在开始获取： System.ComponentModel.Win32Exception： '没有足够的存储空间可用于处理此命令'。

我不太确定是什么原因导致该消息，因为该应用程序不占用大量RAM。

我意识到这个示例应用程序可以一次启动所有线程，但是我的完整应用程序确保只有4个线程在运行，并且一段时间后我仍然收到此消息。 我不知道为什么，但是即使重新启动应用程序和Visual Studio之后，我也无法摆脱此消息。 对造成此消息的原因进行一些澄清会很有用。

所以我的问题是-如果我只需要说4个线程，一次运行-有没有办法我可以创建4个VBScriptEngine实例并在每个新线程调用中重用它？ 还是在主线程上只有一个VBScriptEngine实例，每个新线程都共享它？

Answer 1

在ClearScript团队的帮助下，每个线程仅使用1个专用引擎实例就能够使我的示例应用程序正常工作。 诀窍是先使用自己的线程创建所有必需的引擎，然后在我的循环中使用Dispatcher.Invoke（）调用我的线程函数。 这是使用此方法的更新示例应用程序：

    static void Main(string[] args)
    {
        var vbengines = new VBScriptEngine[Environment.ProcessorCount];
        var checkPoint = new ManualResetEventSlim();
        for (var index = 0; index < vbengines.Length; ++index)
        {
            var thread = new Thread(indexArg =>
            {
                using (var engine = new VBScriptEngine())
                {
                    vbengines[(int)indexArg] = engine;
                    checkPoint.Set();
                    Dispatcher.Run();
                }
            });
            thread.Start(index);
            checkPoint.Wait();
            checkPoint.Reset();
        }

        Parallel.ForEach(Enumerable.Range(0, 4000), item => {
            var engine = vbengines[item % vbengines.Length];

            engine.Dispatcher.Invoke(() => {
                ThreadedFunc(new myobj() { vbengine = engine, index = item });
            });
        });

        Array.ForEach(vbengines, engine => engine.Dispatcher.InvokeShutdown());

        Console.ReadKey();            
    }

    static void ThreadedFunc(object obj)
    {            
        Console.WriteLine(((myobj)obj).index.ToString() + ": " + ((myobj)obj).vbengine.Evaluate("1+1").ToString());
    }

    class myobj
    {
        public VBScriptEngine vbengine { get; set; }
        public int index { get; set; }
    }

Answer 2

using语句允许垃圾回收器（GC）在不再使用托管对象时自动释放分配给该托管对象的内存，因此不会产生开销。

对于第一个问题，您需要使用lock语句 ，该语句可以确保一个线程不会进入关键部分，而另一个线程处于代码的关键部分：

    private static readonly object locked = new object();

    static void ThreadedFunc(object i)
    {
        // Only one thread will execute this code
        lock (locked)
        {                
            //  When you exit the Using block, the `VBScriptEngine` is going to be disposed
            using (VBScriptEngine vbsengine = new VBScriptEngine())
            {
                Console.WriteLine(i + ": " + vbsengine.Evaluate("1+1"));                    
            }
        }
    } 

如果要设置限制，则可以尝试以下操作：

        Parallel.For(0, 4000, new ParallelOptions
        {
            MaxDegreeOfParallelism = 4 // Thread limit
        }, i =>
          {
              // In this case you don't need to use lock statement, it's already thread safe
              ThreadedFunc(i);
         });