¿Que tipo de VPS seleccionar para ejecutar 100 hilos?

[Andres128]

Hola amigos del foro elhacker

Resulta que necesito comprar un VPS para ejecutar una aplicación (hecha en visual basic) que tiene una lista de cuentas de usuario un total de 100 o más, ahora necesito que se ejecuten simultáneamente las 100 y realice sus peticiones y tareas necesarias, esto es 24/7 días a la semana. (use esta librería para ejecutarlas https://github.com/amibar/SmartThreadPool

Tengo dudas:

1. Los hilos o thread que consumen RAM o procesador o las dos ???

2. Que debo tener en cuenta para seleccionar el VPS que tenga más RAM o un mejor procesador.

3. Cuanto creen que necesite de RAM o de procesador para que funcione bien.

4. Se puede dañar un PC si se ejecutar muchísimos hilos unos 500 al tiempo?? que podría pasar???

Gracias amigos por la ayuda.  

[engel lex]

sin saber que hace tu programa y como es basicamente imposible saber que recomendar, pueden ser 100 operaciones simultaneas que consuman unos pocos ciclos del procesador y 1kb de ram cada uno... o pueden ser unas bestias que requieran  30% de 1 nucleo i3 de 5ta y que consuman 100mb  de ram...

tu como encargado del proceso deberías hacer todas las respectivas pruebas para saber como funciona el programa y saber que exige...

así que simplemente respondo las preguntas

1- consumen ambos, los recursos son exigidos para cada hilo individualmente

2- depende del programa, puede consumir más ram o procesador según el caso

3- depende del programa, nadie sabe cuanto consume ni en que sistema corre... de entrada te digo que minimo 1gb de ram para levantar el sistema operativo apropiadamente

4- no, no se daña... es como afirmar que una pc se daña al abrir muchos programas al mismo tiempo... si son muchos hilos el sistema operativo los organizará en la tabla de prioridades y se procesarán poco a poco... eso si, poco a poco puede ser 0.01 segundo por proceso por nucleo, así que siendo por ejemplo 8 nucleos, serían unos 0.6 segudos para procesar y cerrar todas las peticiones... si no tienes suficiente potencia el sistema operativo se puedes quedar pegado... en ese caso el vps lo detectará y reiniciará

por ejemplo, en mi oficina hice en python un servidor dns que lee una tabla postgres, siendo cada petición 1 hilo, eso lo puede llevar una pc doble nucleo vieja en linux con 2gb de ram sin problema, sin pasar de 50% de procesamiento ni de 50% de ram, sabiendo que son unas 100 peticiones por segundo... así mismo hay otro servidor (php mal diseñado hace muchos años) que al ser apache abre cada vez un hilo... con 8 peticiones por segundo en una maquina más moderna con 4 nucleos y 4 gb de ram... en tope de uso consume mas del 80% de ram y procesador a 100%

eso como aclaratoria que depende mucho del sistema

[Andres128]

@engel lex muchas gracias bro una respuesta muy directa y precisa, me ha servido bastante. Por cierto que herramienta o programa me recomiendas para revisar cuanto consume de RAM la aplicación y cuando procesador esta consumiendo. jeje interesante puedo usar linux para dicha labor, ya veremos. Gracias y saludos brother.

[engel lex]

no vas a poder user linux XD es visual basic, necesitas windows...

no estoy seguro si el mismo ide de .net trae las herramientas de analisis y realmente de herramientas en windows poco se XD

sin embargo aquí un articulo, pero no veo nada para VB
https://en.wikipedia.org/wiki/List_of_performance_analysis_tools

[Andres128]

interesante...Estaba pensando en usar Wine para que me salga barato el VPS, realizare varias pruebas para ver como se comporta gracias amigo por la ayuda.

PD: Soy nuevo en esto de los Hilos pero me parece tan interesante.

[engel lex]

cuidado al usar wine... no es un emulador total que digamos, no emula todo... aunque si puede simular mucho sin problema ni demasiada sobre carga

especialmente para aplicaciones de alta disponibilidad, no juegas con la base D: prueba muy bien wine si lo vas a usar hasta sus limites, porque tiende a dar errores puntuales raros en casos especificos XD

y no olvides si realmente necesitas alta disponibilidad hacer redundancia... 2 servidores identicos en caso que 1 falle

toma en cuenta que los hilos no siempre son la mejor solución... pero es cosa que busques algún libro sobre el mutithreading a profundidad

[Eleкtro]

ejecutar una aplicación que tiene una lista de cuentas de usuario un total de 100 o más, ahora necesito que se ejecuten simultáneamente las 100 y realice sus peticiones y tareas necesarias

Eso no es una buena idea.

Crear tal cantidad como 100 threads provocará una gran demanda de interrupción en la ejecución de cada thread activo por core en la CPU (thread swaping) en el programador de threads del sistema operativo. Dependiendo de lo intensivas que sean esas "peticiones y tareas necesarias" que has mencionado, esto que acabo de mencionar puede ser algo insignificante, o por lo contrario un problema de gravedad a tomarse en cuenta con su debida seriedad.

Por lo general no te conviene en absoluto crear 100 threads, sino más bien crear unos pocos threads (4, 8, 16) y dividir el trabajo entre ellos. De esta manera, 1 thread trabajará sobre más de un elemento distinto (lista de cuenta de usuario), optimizando el trabajo y realizando un uso más eficiente y escalable de los recursos del sistema.

1. Los hilos o thread que consumen RAM o procesador o las dos ???

1- consumen ambos, los recursos son exigidos para cada hilo individualmente

Hay que tener en cuenta que en los lenguajes de alto nivel (abstractos) como VB.NET y C# ( o más bien dicho .NET Framework ) se optimiza el uso de los threads, pues lo que un programador suele llamar thread o hilo, es en realidad un wrapper de alto nivel que abstrae cierta funcionalidad de un thread del sistema. A raíz de esto hay toda una extensa serie de implementaciones abstractas en la librería de clases de .NET Framework para cubrir, administrar y perfeccionar muchos aspectos relacionados con el uso/rendimiento de los threads, empezando por la implementación de un gestionador de threads (un Thread Pool y un Task Scheduler). El compilador de .NET genera ciertas optimizaciones automáticas en las instrucciones designadas al uso de threads, y los runtimes junto al programador de threads del S.O. se encargan de procesarlas y hacer el resto.

Respecto al consumo, los threads de una aplicación .NET comparten el mismo espacio de memoria de la aplicación (como es evidente, pues un thread no es un proceso independiente de la aplicación, sino un subset del proceso padre, como un subset de subprocesos), y siempre que puedan éstos compartirán y consumirán los recursos de otros threads del proceso por así decirlo de forma comprensible. Es decir, que no estrictamente siempre se deberá asignar un espacio extra/adicional para administrar los recursos de un nuevo thread (aparte del tamaño de la pila o call stack que eso sí siempre es independiente en cada thread), el GarbageCollector de .NET determinará lo que se puede aprovechar/compartir/reciclar con otro thread, y lo que se debe destruir pro completo. En general, llegar a comprender de forma fidedigna como .NET administra los recursos de memoria asignados en una aplicación es bastante (muy) complejo y confuso, o al menos a mi me resulta así ...en comparación con otros.

2. Que debo tener en cuenta para seleccionar el VPS que tenga más RAM o un mejor procesador.

2- depende del programa, puede consumir más ram o procesador según el caso

3. Cuanto creen que necesite de RAM o de procesador para que funcione bien.

3- depende del programa, nadie sabe cuanto consume ni en que sistema corre... de entrada te digo que minimo 1gb de ram para levantar el sistema operativo apropiadamente

Equilibrio, así de simple. Ante la duda, siempre se debe buscar un sistema equilibrado para intentar minimizar las consecuencias de un posible impacto negativo en un factor (CPU) o en el otro (RAM).

Evidentemente en este tipo de escenario multihilo, cuantos más cores y núcleos por core es mejor, y a más RAM será todavía mucho mejor.

También se debe tener en cuenta que tipo de actividad realizarán tus threads y tu aplicación en general (ej. cargar montones de imagenes de alta resolución en un buffer de memoria, o realizar operaciones masivas I/O de escritura o lectura en disco con 1000 archivos de forma simultanea) y como de intensiva será dicha actividad. Eso no podemos saberlo nosotros, tú eres el desarrollador de tu código y por el momento no nos has mostrado NADA del código como para poder orientarte... aunque de todas formas y para ser sincero yo sobre servidores privados de máquinas virtuales apenas sé nada xD.

4. Se puede dañar un PC si se ejecutar muchísimos hilos unos 500 al tiempo?? que podría pasar???

4- no, no se daña... es como afirmar que una pc se daña al abrir muchos programas al mismo tiempo... si son muchos hilos el sistema operativo los organizará en la tabla de prioridades y se procesarán poco a poco... eso si, poco a poco puede ser 0.01 segundo por proceso por nucleo, así que siendo por ejemplo 8 nucleos, serían unos 0.6 segudos para procesar y cerrar todas las peticiones... si no tienes suficiente potencia el sistema operativo se puedes quedar pegado... en ese caso el vps lo detectará y reiniciará

eso como aclaratoria que depende mucho del sistema

Poco más puedo aportar a la respuesta del copañero @Engel Lex. Como ya te han dicho: no se "daña", y los efectos observables serían exactamente los mismos que si te pones a iniciar 100 procesos distintos al mismo tiempo: una sobrecarga de recursos que tendrá como consecuencia una ralentización del sistema operativo.

Pero cabría destacar que .NET Framework se encarga de buscar el equilibrio perfecto de una aplicación multihilo, determinando de forma automática la cantidad mímina y máxima de threads que pueden estar iniciados en paralelo al mismo tiempo por dicha aplicación. Esto se decide en base a muchos factores, así que un colapso de recursos en el S.O. es más bien improbable al ser teoricamente imposible de suceder por si solo (a menos que modificases de forma arbitraria los límites de threads mínimos y máximos por defecto en la aplicación).

(use esta librería para ejecutarlas https://github.com/amibar/SmartThreadPool

En mi opinión haces mal al usar una reimplementación de algo que no sea la implementación original de Microsoft, a eso se le llama REINVENTAR LA RUEDA !!. Otra cosa bien distinta sería utilizar una librería que extienda la implementación original para añadirle funcionalidades adicionales, que sinceramente no sé si será el caso, pero por lo poco que he leido en esa página de CodeProject... no parece ser el caso.

Si te fijas bien, verás que ese proyecto lleva en desarrollo desde el año 2003, esto viene a ser el mismo año en el que se utilizaba .NET Framework 1.0, es en ese año cuando nació ese proyecto de CodeProject, y puede que por aquél entonces si que valiese la pena utilizar una implementación de terceros del thread pool de .NET Framework, ya que simplemente era la versión 1.0 del producto y había muchas cosas que pulir, pero hoy en dia francamente ese tipo de librerías las veo algo de lo más innecesario y sin mucha utilidad real (pues quien la use solo la usará por simple desconocimiento de como llevar a cabo la misma tarea de forma "nativa" o guiada mediante el instrumental que provee .NET Framework ), además solo conseguirías obtener justo lo opuesto a ese rendimiento óptimo que estás buscando...

En .NET Framework, la cantidad máxima de threads administrados que puedes mantener activos (por defecto) se determina en base a muchos factores, podemos abreviar todos estos factores como un conjunto de recursos (RAM) y disponibilidad de cores en CPU. El máximo límite de threads que puedes iniciar de forma simultanea se ve incrementado en cada versión de .NET Framework. Te puedo decir que el límite es de 1023 threads administrados en .NET Framework 4.0, y 2047 en .NET Framework 4.6, ojo, eso solamente en aplicaciones de 32 Bits, ya que este número se ve multiplicado por 16 para una aplicación de 64-Bits, siendo así un límite máximo de 32.767 threads en el thread pool de .NET Framework 4.6 x64. Luego existe un límite de threads de operaciones I/O, cuyo valor no varia y siempre son 1.000 (pero también lo puedes modificar). De todas formas estamos hablando de números/límites muy altos que probablemente nunca podrán ser revasados por una aplicación "normal", y de intentarlo posría provocar un desbordmiento (overflow) de la pila o stack de la aplicación.

Otro motivo por el cual me resulta innecesaria esa reimplementación...que te la "venden" como si fuese la única posibilidad de poder asignar un límite mínimo de threads activos de forma simultanea, es que la librería de clases de .NET Framework proporciona miembros para modificar tanto el límite mínimo como el máximo de threads en tu aplicación (aunque por otro lado esto no limita la cantidad mínima ni máxima de threads dedicados en la aplicación): System.Threading.ThreadPool.SetMinThreads() y System.Threading.ThreadPool.SetMaxThreads(), y además provee varias alternativas de hacer "lo mismo", por orden de abstracción de un thread del sistema: la clase Thread, BackgroundWorker, y Task, cada una de ellas enfocada a distintos escenarios (thread dedicado, thread que necesite interactuar con los controles de la UI, thread 'fire and forget', etc).

¿Todavía sigues creyendo que necesitas recurrir a una librería de terceros para poder ejecutar 100 threads de forma simultanea en una aplicación .NET?, no, en absoluto, y como ya digo... solamente conseguirías desaprovechar los beneficios de la implementación de Microsoft, no obtendrías ese rendimiento óptimo que buscas.

En mi opinión, para lo que pretendes hacer creo que te serviría de mucho usar la clase ThreadPool de .NET. Mientras que la creación y ejecución de un thread administrado (clase: System.Threading.Thread) puede resultar una operación expensiva para el S.O., la clase ThreadPool rehusa los threads y amortigua esos costes adicionales de creación y ejecución. Además, dicha clase ayuda a simpliicar el procedimiento de creación, ejecución y detención/aborto de los threads.

Aquí te muestro un ejemplo de como utilizar el Thread Pool de .NET para mantener 100 threads activos (como mínimo) de forma simultanea:

VB.NET

Código (vbnet) [Seleccionar] Expandir

Imports System
Imports System.Diagnostics
Imports System.Threading

Public Module Module1

   <MTAThread>
   Public Sub Main()

       Dim minThreadCount As Integer = 100
       Dim maxThreadCount As Integer
       Dim minIOThreadCount As Integer
       Dim maxIOThreadCount As Integer

       ThreadPool.GetMinThreads(Nothing, minIOThreadCount)
       ThreadPool.GetMaxThreads(maxThreadCount, maxIOThreadCount)
       If (maxThreadCount <= minThreadCount) Then
           maxThreadCount = (minThreadCount + 1)
       End If

       ThreadPool.SetMinThreads(minThreadCount, minIOThreadCount)
       ThreadPool.SetMaxThreads(maxThreadCount, maxIOThreadCount)

       Debug.WriteLine("Minimum Thread Count: {0}", minThreadCount)
       Debug.WriteLine("Maximum Thread Count: {0}", maxThreadCount)

       For i As Integer = 0 To Byte.MaxValue ' Loop trough 0 to 255
           Dim wcb As New WaitCallback(AddressOf MyThreadWork)
           ThreadPool.QueueUserWorkItem(wcb, Nothing)
       Next i
       Thread.Sleep(TimeSpan.FromSeconds(1))

       Dim activeThreadCount As Integer = Process.GetCurrentProcess().Threads.Count
       Debug.WriteLine("Amount of active threads: {0}", activeThreadCount)
       Console.ReadKey()
       Environment.Exit(0)

   End Sub

    ' <MethodImpl(MethodImplOptions.Synchronized)>
   Private Sub MyThreadWork(ByVal stateInfo As Object)
       Thread.Sleep(Timeout.Infinite)
   End Sub

End Module

C#

Código (csharp) [Seleccionar] Expandir

using System;
using System.Diagnostics;
using System.Threading;

namespace ConsoleApp1 {

   class Program {

       [MTAThread()]
       static void Main(string[] args) {

           int minThreadCount = 100;
           int maxThreadCount = 0;
           int minIOThreadCount = 0;
           int maxIOThreadCount = 0;

           ThreadPool.GetMinThreads(out int nul, out minIOThreadCount);
           ThreadPool.GetMaxThreads(out maxThreadCount, out maxIOThreadCount);
           if (maxThreadCount <= minThreadCount) {
               maxThreadCount = (minThreadCount + 1);
           }

           ThreadPool.SetMinThreads(minThreadCount, minIOThreadCount);
           ThreadPool.SetMaxThreads(maxThreadCount, maxIOThreadCount);

           Debug.WriteLine("Minimum Thread Count: {0}", minThreadCount);
           Debug.WriteLine("Maximum Thread Count: {0}", maxThreadCount);

           for (int i = 0; i <= byte.MaxValue; i++) { // Loop trough 0 to 255
               WaitCallback wcb = new WaitCallback(MyThreadWork);
               ThreadPool.QueueUserWorkItem(wcb, null);
           }
           Thread.Sleep(TimeSpan.FromSeconds(1));

           int activeThreadCount = Process.GetCurrentProcess().Threads.Count;
           Debug.WriteLine("Amount of active threads: {0}", activeThreadCount);
           Console.ReadKey();
           Environment.Exit(0);

       }

       // [MethodImpl(MethodImplOptions.Synchronized)]
       static void MyThreadWork(object stateInfo) {
           Thread.Sleep(Timeout.Infinite);
       }
   }
}

También puedes hacer uso del paralelismo para iniciar una determinada cantidad de tareas en paralelo (léase: threads) de forma simultanea (en base a los límites actuales establecidos en el thread pool de .NET):

VB.NET:

Código (vbnet) [Seleccionar] Expandir

Imports System
Imports System.Diagnostics
Imports System.Threading
Imports System.Threading.Tasks

Public Module Module1

   <MTAThread>
   Public Sub Main()

       Dim minThreadCount As Integer = 100
       Dim maxThreadCount As Integer
       Dim minIOThreadCount As Integer
       Dim maxIOThreadCount As Integer

       ThreadPool.GetMinThreads(Nothing, minIOThreadCount)
       ThreadPool.GetMaxThreads(maxThreadCount, maxIOThreadCount)
       If (maxThreadCount <= minThreadCount) Then
           maxThreadCount = (minThreadCount + 1)
       End If

       ThreadPool.SetMinThreads(minThreadCount, minIOThreadCount)
       ThreadPool.SetMaxThreads(maxThreadCount, maxIOThreadCount)

       Dim options As New ParallelOptions() With {
           .CancellationToken = CancellationToken.None,
           .TaskScheduler = TaskScheduler.Current,
           .MaxDegreeOfParallelism = minThreadCount
       }

       Dim action As New Action(Of Integer, ParallelLoopState)(AddressOf MyThreadWork)

       Parallel.For(0, Byte.MaxValue, options, action) ' Loop trough 0 to 255

       Console.ReadKey()
       Environment.Exit(0)

   End Sub

   ' <MethodImpl(MethodImplOptions.Synchronized)>
   Private Sub MyThreadWork(ByVal i As Integer, state As ParallelLoopState)
       Static flag As Boolean = False
       Dim activeThreadCount As Integer = Process.GetCurrentProcess().Threads.Count
       If (activeThreadCount >= 100) AndAlso Not (flag) Then
           flag = Not flag
           Debug.WriteLine("Amount of active threads: {0}", activeThreadCount)
       End If
       Thread.Sleep(Timeout.Infinite)
   End Sub

End Module

C#

Código (csharp) [Seleccionar] Expandir

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1 {

   class Program {

       [MTAThread()]
       static void Main(string[] args) {

           int minThreadCount = 100;
           int maxThreadCount = 0;
           int minIOThreadCount = 0;
           int maxIOThreadCount = 0;

           ThreadPool.GetMinThreads(out int nul, out minIOThreadCount);
           ThreadPool.GetMaxThreads(out maxThreadCount, out maxIOThreadCount);
           if (maxThreadCount <= minThreadCount) {
               maxThreadCount = (minThreadCount + 1);
           }

           ThreadPool.SetMinThreads(minThreadCount, minIOThreadCount);
           ThreadPool.SetMaxThreads(maxThreadCount, maxIOThreadCount);

           Debug.WriteLine("Minimum Thread Count: {0}", minThreadCount);
           Debug.WriteLine("Maximum Thread Count: {0}", maxThreadCount);

           ParallelOptions options = new ParallelOptions {
               CancellationToken = CancellationToken.None,
               TaskScheduler = TaskScheduler.Current,
               MaxDegreeOfParallelism = minThreadCount
           };

           Action<int, ParallelLoopState> action = new Action<int, ParallelLoopState>(MyThreadWork);

           Parallel.For(0, byte.MaxValue, options, action); // Loop trough 0 to 255

           Console.ReadKey();
           Environment.Exit(0);

       }

       static bool flag = false;
       // [MethodImpl(MethodImplOptions.Synchronized)]
       static void MyThreadWork(int i, ParallelLoopState state) {
           int activeThreadCount = Process.GetCurrentProcess().Threads.Count;
           if ((activeThreadCount >= 100) && !(flag)) {
               flag = !flag;
               Debug.WriteLine("Amount of active threads: {0}", activeThreadCount);
           }
           Thread.Sleep(Timeout.Infinite);
       }
   }
}

Estaba pensando en usar Wine para que me salga barato el VPS, realizare varias pruebas para ver como se comporta

Hace muuuchos años que no manejo de forma seria Linux ni Wine; las cosas habrán cambiado mucho desde aquél entonces, se supone que ahora Wine permite instalar .NET Framework y hasta la versión 4.6 nada menos, pero lo cierto es que si tu intención es instalar Wine para poder ejecutar esa aplicación desarrollada en VB.NET... entonces NO NECESITAS USAR WINE. Además de por si la idea de usar un pseudo-emulador para solucionar el problema no debería ser tu primera opción.

...¿Y entonces cómo hacerlo?, pues bien, para empezar te hago saber que tienes a tu disposición una implementación de terceros de .NET Framework multiplataforma llamada Mono, que es capaz de correr aplicaciones desarrolladas para la plataforma .NET Framework en Linux. No es estrictamente necesario desarrollar la aplicación con la IDE Mono Develop (pero si recomendable para no cometer errores de compatibilidad), puedes desarrollar la aplicación de forma normal con Visual Studio, ya que las librerías de los runtimes de Mono solo se necesitan para iniciar la aplicación.

Y mucho mejor que Mono tienes una opción más óptima a tu disposición: desde hace unos pocos años Microsoft provee una implementación reducida y multiplataforma de .NET Framework llamada .NET Core, que al igual que Mono nos permite crear aplicaciones para Linux, con todos los beneficios y optimizaciones que ello implica por la garantia Made In Microsoft .

En fin, espero que algo de todo lo que expliqué te haya podido servir de ayuda.

Saludos!

[engel lex]

disculpa, nunca me metí en el lio de mono... pero no era super limitaday era una vago intento de netframework incompleto?... eso recuerdo hasta la ultima vez que vi el proyecto :s

[Serapis]

En un procesador de sobremesa, es un error pretender arrancar 100 hilos simultáneos.

Dado la cantidad de cores del procesador, el resto será procesado paralelo simulado, es decir cesión de tiempos y recursos compartidos. Luego si no va a ser paralelo real, tampoco hay necesaidad de crear 100 hilos con sus respectivo consumo. es preferible que crees solo 2,4,6 y que internamente seas tú quien vaya rotando entre procesos. El resultado final será más óptimo de esta manera (salvo que lo programes muy mal), ya que en un momento dado, cada proceso en marcha tendrá a su disposición la casi totalidad de recursos (la memoria reservada por los procesos comenzados ya está ocupada). Incluso sería más óptimo realizarlos en serie, cuando uno acabe que inice otro, así si solo hay 4 hilos, la memoria está disponible para 'repartir' entre 4 procesos, no para 'repartir' entre 100...

Si existe la necesaidad real de que deban ser paralelos porque realizan tareas en tiempo real, entonces lo razonable es disponer de una red de ordenadores y que uno actúe de servidor repartiendo las tareas entre el resto....

[Andres128]

@engel lex Gracias amigo por interesarles el tema de los hilos es tan fascinante.

@Eleкtro :O impresionante, me quito el sombrero, tanto conocimiento que tienes no logro entender como le hacen para saber tanto, te pareces al .paul y a jmcilhinney de vbforums, conocen estos lenguajes profundamente.

Gracias por compartir el conocimiento conmigo me ha servido muchísimo    , pasando a al tema de la aplicación les cuento un poco lo que hace, se basa en hacer follow y unfollow en una red social famosa, sin embargo constantemente utiliza archivos de texto para almacenar datos de los usuarios (SI yo se que debí usar bases de datos (era novato cuando lo inicie), pero bueno ahorita no puedo cambiar por que seria empezar desde 0 y no tengo tiempo), simplemente hace eso, claro esta que son varias peticiones, como logueo, follow, unfollow, revisar el usuario obtener su nombre, escribir archivo de texto, leerlos, etc.

Si yo ya había probado ThreadPool.QueueUserWorkItem y el Parallel pero no me habían dado el resultado esperado (me había saltado el WaitCallback de pronto por eso fue), voy a probar ya mismo tus ejemplos están muy interesante  bueno y como no me daban el resultado encontré esa librería de terceros SmartThreadPool su ultima versión fue el 2016 https://www.nuget.org/packages/SmartThreadPool.dll/ , seguiré probando y aprendiendo.

No tenia ni idea de que era IDE Mono Develop excelente dato.

@Eleкtro ultima duda en el caso ThreadPool.QueueUserWorkItem como hago para esperar a que terminen de trabajar, es decir un waitall para que se espere hasta que terminen de trabajar los hilos???

@engel lex buen dato bro, saludos. Pero como hago eso, es que necesito que se ejecuten simultáneamente por que las acciones y tareas por cuenta se demora como 3 o 4 horas, no se como dividir tareas en un hilo  

Se podría con pipe https://www.codeproject.com/Articles/7933/Smart-Thread-Pool#PipeExample