C++ cli 线程池执行延迟怀疑

我在一个循环中对10个委托调用了BeginInvoke。线程池只使用两个或三个线程来执行委托，而不是使用10个线程。谁能解释一下原因吗？。委托执行只需要几毫秒（少于10毫秒）

当我在调用BeginInvoke之前记录线程池参数时，它表明最小线程数=2，最大线程数=500，可用线程数=498

---

当调用下面的托管C++代码时，我遇到了问题。p>

void EventHelper::FireAndForget(Delegate^ d, ... array<Object^>^ args)
            {
                try
                {
                    if (d != nullptr)
                    {                                           
                        array<Delegate^>^ delegates = d->GetInvocationList();   

                        String^ message1 = String::Format("No of items in the event {0}",delegates.Length);
                        Log(LogMessageType::Information,"EventHelper.FireAndForget", message1);

                        // Iterating through the list of delegate methods.
                        for each(Delegate^ delegateMethod in delegates)
                        {
                            try
                            {
                                int minworkerThreads,maxworkerThreads,availworkerThreads, completionPortThreads;
                                ThreadPool::GetMinThreads(minworkerThreads, completionPortThreads);
                                ThreadPool::GetMaxThreads(maxworkerThreads, completionPortThreads);
                                ThreadPool::GetAvailableThreads(availworkerThreads, completionPortThreads);

                                String^ message = String::Format("FireAndForget Method {0}#{1} MinThreads - {2}, MaxThreads - {3} AvailableThreads - {4}",
                                                delegateMethod->Method->DeclaringType, delegateMethod->Method->Name, minworkerThreads, maxworkerThreads, availworkerThreads);

                                Log(LogMessageType::Information,"EventHelper.FireAndForget", message);

                                DynamicInvokeAsyncProc^ evtDelegate = gcnew DynamicInvokeAsyncProc(this, &EventHelper::OnTriggerEvent);
                                evtDelegate->BeginInvoke(delegateMethod, args, _dynamicAsyncResult, nullptr); //FIX_DEC_09 Handle Leak    
                            }
                            catch (Exception^ ex)
                            {
                                String^ message = String::Format("{0} : DynamicInvokeAsync of '{1}.{2}' failed", _id,
                                                                    delegateMethod->Method->DeclaringType, d->Method->Name);

                                Log(LogMessageType::Information,"EventHelper.FireAndForget", message);                              
                            }
                        }
                    }
                    else
                    {                   
                    }
                }
                catch (Exception^ e)
                {
                    Log(LogMessageType::Error, "EventHelper.FireAndForget", e->ToString());
                }

            }

void EventHelper:：FireAndForget（委托^d，…数组^args）
{
尝试
{
如果（d！=nullptr）
{                                           
数组^delegates=d->GetInvocationList（）；
String^message1=String:：Format（“事件{0}中的项目数”，delegates.Length）；
日志（LogMessageType:：信息，“EventHelper.FireAndForget”，message1）；
//遍历委托方法列表。
对于每个（委托中的委托^delegateMethod）
{
尝试
{
int minworkerThreads、maxworkerThreads、availworkerThreads、completionPortThreads；
线程池：：GetMinThreads（minworkerThreads，completionPortThreads）；
线程池：：GetMaxThreads（maxworkerThreads，completionPortThreads）；
线程池：：GetAvailableThreads（availworkerThreads，completionPortThreads）；
String^message=String:：Format（“FireAndForget方法{0}{1}MinThreads-{2}，MaxThreads-{3}AvailableThreads-{4}”，
delegateMethod->Method->DeclaringType，delegateMethod->Method->Name，minworkerThreads，maxworkerThreads，availworkerThreads）；
日志（LogMessageType:：信息，“EventHelper.FireAndForget”，消息）；
DynamicInvokeAsyncProc^evtDelegate=gcnew DynamicInvokeAsyncProc（this，&EventHelper:：OnTriggerEvent）；
evtDelegate->BeginInvoke（delegateMethod，args，_dynamicAsyncResult，nullptr）；//修复_DEC_09句柄泄漏
}
捕获（异常^ex）
{
String^message=String:：Format（“{0}:DynamicInvokeAsync of'{1}.{2}'失败“，\u id，
委托方法->方法->去极化类型，d->方法->名称）；
日志（LogMessageType:：信息，“EventHelper.FireAndForget”，消息）；
}
}
}
其他的
{                   
}
}
捕获（异常^e）
{
日志（LogMessageType:：Error，“EventHelper.FireAndForget”，e->ToString（））；
}
}

---

这是代表中给出的方法

void EventHelper::OnTriggerEvent(Delegate^ delegateMethod, array<Object^>^ args)
            {
                try
                {
                    int minworkerThreads,maxworkerThreads,availworkerThreads, completionPortThreads;
                    ThreadPool::GetMinThreads(minworkerThreads, completionPortThreads);
                    ThreadPool::GetMaxThreads(maxworkerThreads, completionPortThreads);
                    ThreadPool::GetAvailableThreads(availworkerThreads, completionPortThreads);

                    String^ message = String::Format("OnTriggerEvent Method {0}#{1} MinThreads - {2}, MaxThreads - {3} AvailableThreads - {4}",
                                    delegateMethod->Method->DeclaringType, delegateMethod->Method->Name, minworkerThreads, maxworkerThreads, availworkerThreads);
                    Log(LogMessageType::Information,"EventHelper::OnTriggerEvent", message);

                    message = String::Format("Before Invoke Method {0}#{1}",
                                                delegateMethod->Method->DeclaringType, delegateMethod->Method->Name);
                    Log(LogMessageType::Information,"EventHelper::OnTriggerEvent", message);

                    // Dynamically invokes (late-bound) the method represented by the current delegate. 
                    delegateMethod->DynamicInvoke(args);
                    message = String::Format("After Invoke Method {0}#{1}",
                                                delegateMethod->Method->DeclaringType, delegateMethod->Method->Name);
                    Log(LogMessageType::Information,"EventHelper::OnTriggerEvent", message);
                }
                catch (Exception^ ex)
                {
                    Log(LogMessageType::Error, "EventHelper.OnTriggerEvent", ex->ToString());
                }
            }

void EventHelper:：OnTiggerEvent（委托^delegateMethod，数组^args）
{
尝试
{
int minworkerThreads、maxworkerThreads、availworkerThreads、completionPortThreads；
线程池：：GetMinThreads（minworkerThreads，completionPortThreads）；
线程池：：GetMaxThreads（maxworkerThreads，completionPortThreads）；
线程池：：GetAvailableThreads（availworkerThreads，completionPortThreads）；
String^message=String:：Format（“OnTiggerEvent方法{0}{1}MinThreads-{2}，MaxThreads-{3}AvailableThreads-{4}”，
delegateMethod->Method->DeclaringType，delegateMethod->Method->Name，minworkerThreads，maxworkerThreads，availworkerThreads）；
日志（LogMessageType:：Information，“EventHelper:：OnTriggerEvent”，消息）；
message=String:：Format（“在调用方法{0}{1}之前”，
委托方法->方法->去极化类型，委托方法->方法->名称）；
日志（LogMessageType:：Information，“EventHelper:：OnTriggerEvent”，消息）；
//动态调用（后期绑定）由当前委托表示的方法。
delegateMethod->DynamicInvoke（args）；
message=String:：Format（“在调用方法{0}{1}之后”，
委托方法->方法->去极化类型，委托方法->方法->名称）；
日志（LogMessageType:：Information，“EventHelper:：OnTriggerEvent”，消息）；
}
捕获（异常^ex）
{
日志（LogMessageType:：Error，“EventHelper.OnTriggerEvent”，ex->ToString（））；
}
}

线程池在启动新线程之前故意等待一段时间-如果代理执行速度很快（听起来像是这样），那么在几个线程上执行它们比启动新线程更有效

从：

当所有线程池线程都已运行时 分配给任务的线程池 不会立即开始创建 新的空闲线程。避 不必要地分配堆栈空间 对于线程，它会创建新的空闲线程 每隔一段时间穿几条线。间隔时间是 现在是半秒，虽然 在未来版本的 .NET Framework..NET Framework

---

您不希望为此创建10个线程。最佳情况是拥有与核心数量相同的活动线程。您会发现ThreadPool.MinThreads等于logi的#