Formularios en hilos
separados en
Visual Basic NET
En ocasiones tenemos una aplicación válida con
2 formularios, desde el primero en aparecer iniciamos el otro y, al cerrar el primer
formulario, se cierra el segundo automáticamente. Pero en otras ocasiones puede
interesarnos que el cierre del primer formulario no conlleve el cierre del segundo,
es decir, que ambos formularios sean verdaderamente independientes y que ambos se
inicien a la vez (al arrancar la aplicación).
El comportamiento descrito en el primer párrafo, habitual en las aplicaciones de
Visual Basic .NET construidas por defecto, se debe a que ambos formularios se ejecutan
en el mismo hilo del proceso principal por lo que, al cerrar el primer formulario,
terminamos ese hilo y todo lo que en él tiene lugar, incluido el segundo formulario.
La solución a este problema pasa por crear 2 hilos separados, y ejecutar cada uno
de los formularios en cada uno de los hilos, de esta manera los independizamos hasta
el punto que podemos cerrar el primer formulario y el segundo no se ve afectado.
Aunque los programadores poco expertos puedan deducir del texto anterior que debe
tratarse de un código muy complejo y difícil de entender, el código necesario para
ello es corto y bastante sencillo:
- En primer lugar es necesario importar el espacio de nombres System.Threading
que proporciona clases e interfaces que permiten la programación multiproceso.
- Después hay que crear un procedimiento Main() específico por código,
en él se crean las 2 hebras o hilos diferentes, apuntadas hacia 2 procedimientos
tambien distintos encargados de arrancar cada uno de los formularios.
Para comprender mejor este ejercicio, conviene recordar algunos conceptos básicos
acerca de multitarea, procesos e hilos:
- Multithreading (Multitarea): Nombre que se le da a las arquitecturas
que implementan múltiples hilos de control.
- Thread: Concepto base de la programación multitarea. Traducido como
hilo, hebra, flujo de control o contexto de ejecución
dentro de un proceso. Es la unidad planificable para ejecución por la biblioteca
de hilos o por el kernel.
- Planificación: Es el proceso que consiste en decidir qué hilo se
ejecutará a continuación en un determinado procesador.
- Hilo Independiente: Es un hilo cuya finalización no es esperada por
ningún otro hilo, de forma que si el hilo finaliza, es destruido inmediatamente,
ya que no se necesita mantener su estado en memoria en espera de la sincronización
con otro hilo.
- Hilo Sincronizable: Es un hilo cuya finalización debe ser esperada
por algún hilo (normalmente el hilo que lo creó).
- Hilo-seguro: Normalmente se dice que un código es hilo-seguro si
puede ser ejecutado en un programa multihilo sin problemas. Es decir, es código
que puede ser llamado por varios hilos al mismo tiempo.
- Hilo-no-seguro: Es aquel código que no está preparado para ser ejecutado
en una aplicación multihilo. Una solución a este problema es emplear un bloqueo
global antes de llamar a este tipo de código, lo que garantiza que sólo un hilo
estará ejecutando el código en un momento dado.
- Hilos de Nivel Kernel: Son los hilos soportados por el kernel o núcleo
del sistema operativo. Estos hilos son gestionados y planificados por el kernel.
- Hilos de Nivel Usuario: Son los hilos soportados por la biblioteca
o paquete de hilos, y no son conocidos por el kernel del sistema operativo.
- Sección Crítica: Es una región de código en la que los datos a los
que se accede pueden ser también accedidos por otros hilos, con lo que se pueden
obtener inconsistencias en los valores de los datos. Para evitar estos problemas
se suelen emplear objetos de sincronización o bloqueos.
Pulsa
aquí para ver el código completo
en Visual Basic .NET.