Problema de gran volumen de datos en C#
Lo siguiente es reproducido por otros. Hay muchísimo material como este. De hecho, es muy sencillo observar los materiales con atención.
El material de referencia es muy detallado.
1. Introducción a los subprocesos
Normalmente los programas C# tienen un solo subproceso. Este hilo comienza desde la ejecución del método principal y finaliza cuando finaliza la ejecución del método principal. Cada comando ejecutado directa o indirectamente por Main es ejecutado por el hilo predeterminado (o hilo principal), y este hilo también finalizará cuando Main regrese. Sin embargo, puede crear subprocesos de trabajo para ejecutar código en paralelo con el subproceso principal. Estos subprocesos a menudo se denominan "subprocesos de trabajo".
Se puede utilizar un subproceso secundario para realizar tareas que requieren mucho tiempo o que requieren mucho tiempo sin ocupar el subproceso principal. Por ejemplo, en aplicaciones de servidor, los subprocesos de trabajo se utilizan a menudo para responder a solicitudes entrantes sin esperar a que se completen las solicitudes anteriores. Los subprocesos de trabajo también se pueden utilizar para realizar tareas "en segundo plano" en aplicaciones de escritorio de modo que el subproceso principal (que controla los elementos de la interfaz de usuario) siga respondiendo a las acciones del usuario.
Los subprocesos múltiples resuelven los problemas de rendimiento y capacidad de respuesta, pero también generan problemas de intercambio de recursos, como interbloqueos y estados de contención. El subproceso múltiple es particularmente adecuado para tareas que requieren diferentes recursos, como identificadores de archivos y conexiones de red. Asignar varios subprocesos a un único recurso puede generar problemas de sincronización, ya que los subprocesos frecuentemente se bloquean esperando a otros subprocesos, lo que anula el propósito de utilizar subprocesos múltiples en primer lugar.
Una estrategia común es utilizar un subproceso secundario para realizar tareas que requieren mucho tiempo o son críticas y que no consumen muchos recursos utilizados por otros subprocesos. De hecho, varios subprocesos deben acceder a algunos recursos del programa. Teniendo en cuenta estas circunstancias, el sistema. El espacio de nombres de subprocesos proporciona clases para sincronizar subprocesos. Estas clases incluyen mutex, monitor, interbloqueo, evento de reinicio automático y evento de reinicio manual.
Puede utilizar algunas o todas estas clases para sincronizar la actividad de varios subprocesos, pero el lenguaje C# proporciona cierto soporte para subprocesos múltiples. Por ejemplo, la instrucción Lock en C# proporciona sincronización mediante el uso implícito de un monitor.
En segundo lugar, el ciclo de vida del subproceso.
En tercer lugar, las clases relacionadas con subprocesos
y las clases relacionadas con C# están todas en el sistema. Espacio de nombres de subprocesos, que proporciona algunas clases e interfaces que admiten programación multiproceso. Además de clases para sincronizar la actividad de los hilos y acceder a los datos (mutex, monitoreo, enclavamientos, eventos de reinicio automático, etc.). ), este espacio de nombres también contiene una clase ThreadPool (que permite a los usuarios usar el grupo de subprocesos proporcionado por el sistema) y una clase Timer (que ejecuta métodos de devolución de llamada en los subprocesos del grupo de subprocesos).
1. Hilos: Crear y controlar hilos, establecer sus prioridades y obtener su estado. Los métodos más utilizados son los siguientes:
Sleep(): bloquea el hilo actual durante el número especificado de milisegundos.
Abort(): ThreadAbortException se lanza en el hilo que llama a este método para iniciar el proceso de finalización de este hilo. Llamar a este método normalmente finaliza el hilo.
Join(): bloquea el hilo que llama hasta que el hilo termina.
Inicio(): permite que el hilo se ejecute según lo planeado.
Tenga en cuenta que Suspend() es un hilo suspendido y Resume() es un hilo que continúa suspendido. Ambos métodos son riesgosos y no recomendados. Consulte la documentación de MS correspondiente para obtener más detalles.
Las propiedades comunes de la clase Thread son las siguientes:
CurrentThread: Obtiene el hilo que se está ejecutando actualmente.
IsAlive: Obtiene un valor que indica el estado de ejecución del hilo actual.
Nombre: Obtiene o establece el nombre del hilo.
Prioridad: Obtiene o establece un valor que indica la prioridad de programación del hilo.
ThreadState: Obtiene un valor que contiene el estado actual del hilo.
2.ThreadPool: proporciona un grupo de subprocesos que se puede utilizar para enviar elementos de trabajo, manejar E/S asincrónicas, esperar en nombre de otros subprocesos y manejar temporizadores.
BindHandle: vincula el identificador del sistema operativo al grupo de subprocesos.
GetAvailableThreads: recupera la diferencia entre el número máximo de grupos de subprocesos devueltos por el método GetMaxThreads y el número actual de subprocesos activos.
GetMaxThreads: Recupera el número de solicitudes de grupo de subprocesos que pueden estar activas al mismo tiempo. Todas las solicitudes superiores a este número se pondrán en cola hasta que un subproceso del grupo de subprocesos esté disponible.
GetMinThreads: recupera el número de subprocesos inactivos mantenidos por el grupo de subprocesos en predicciones de nuevas solicitudes.
QueneUserWorkItem: Métodos de colas para su ejecución. Este método se ejecuta cuando un subproceso del grupo de subprocesos está disponible.
RegisterWaitForSingleObject: registra el delegado que espera WaitHandle.
UnsafeQueueUserWorkItem: registra un delegado que está esperando WaitHandle.
SetMaxThreads: Establece el número de solicitudes que pueden estar activas al mismo tiempo para un grupo de subprocesos. Todas las solicitudes superiores a este número se pondrán en cola hasta que un subproceso del grupo de subprocesos esté disponible.
Cuatro. Ejemplos y explicaciones
Utilizar el sistema;
Utilizar el sistema. Threading;
Trabajador de clase pública
{
//Este método se llamará cuando se inicie el hilo.
public void DoWork()
{
Y (!_shouldStop) //Si el hilo se está ejecutando, imprime la información.
{
Consola. WriteLine("Subproceso de trabajo: Trabajando...");
}
Console. WriteLine("Subproceso de trabajo: terminado normalmente.");
}
Public void RequestStop()
{
_ deberíaStop = true
}
//La palabra clave volátil se utiliza para recordarle al compilador que varios subprocesos accederán a este miembro de datos.
Variable privada bool _ shouldStop//Debería detenerse.
}
Curso Público
{
Tubería principal de aire estático ()
{
//Crea un objeto de hilo. Este no es el comienzo del hilo.
Trabajador Objeto trabajador = new Worker();
//Defina un nuevo hilo aquí. Tenga en cuenta que aquí no se utiliza el delegado ThreadStart.
//Además, el constructor acepta el nombre del método del objeto.
Subproceso workThread = nuevo subproceso (workerObject.DoWork);
//Este es el comienzo real del subproceso.
Hilo de trabajador. start();
Consola. WriteLine("Hilo principal: el hilo de trabajo comienza...");
//Bucle hasta que se active el hilo. La propiedad IsAlive del hilo indica si el hilo está activo.
while(!worker thread. isa live);
// Pausa el hilo principal durante 1 milisegundo para permitir que el hilo de trabajo complete su trabajo.
Hilo. Sleep(1);
//Requiere que el hilo de trabajo se detenga automáticamente.
Objeto de trabajo. request stop();
//Utilice el método Join para bloquear el hilo actual hasta que el hilo del objeto termine el hilo de trabajo. unirse();
Consola. WriteLine("Hilo principal: el hilo de trabajo ha terminado.");
}
}