Empleo de hilos

2.4 Relaciones y Contexto

El empleo de hilos está estrechamente relacionado con otros conceptos del curso, como:

• Sistemas distribuidos: donde múltiples procesos en diferentes máquinas ejecutan tareas paralelas.
• Sistemas interactivos: interfaces gráficas que requieren actualización constante sin bloquear la interacción del usuario.
• Sistemas empresariales: servidores web o bases de datos que manejan múltiples solicitudes simultáneamente.

Además, el uso correcto de hilos complementa técnicas como la programación orientada a eventos y el manejo eficiente de recursos en aplicaciones complejas.

3. Ejemplos Aplicados

Ejemplo 1: Creación básica de un hilo en Java

Supuesta una aplicación sencilla que realiza dos tareas independientes: imprimir números pares e impares hasta 10. Se implementa creando dos clases que extienden Thread.

public class ParThread extends Thread {
    public void run() {
        for (int i = 0; i <= 10; i += 2) {
            System.out.println("Par: " + i);
            try {
                Thread.sleep(500); // pausa para simular procesamiento
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ImparThread extends Thread {
    public void run() {
        for (int i = 1; i <= 10; i += 2) {
            System.out.println("Impar: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class EjemploHilos {
    public static void main(String[] args) {
        ParThread t1 = new ParThread();
        ImparThread t2 = new ImparThread();
        t1.start();
        t2.start();
    }
}

Cada hilo imprime números alternos con pausas intercaladas, demostrando ejecución concurrente. La salida será intercalada debido a la planificación del sistema operativo.

Ejemplo 2: Hilo en una aplicación empresarial - servidor web multihilo

Pensemos en un servidor web que recibe múltiples solicitudes simultáneas. Cada solicitud se maneja mediante un hilo independiente para evitar bloqueos y mejorar la capacidad de respuesta. En Java EE o frameworks similares, esto se implementa creando un nuevo hilo por cada petición o mediante pools gestionados por el servidor.

public class PeticionHandler implements Runnable {
    private Socket cliente;

    public PeticionHandler(Socket cliente) {
        this.cliente = cliente;
    }

    public void run() {
        // Procesamiento de solicitud
        // Leer petición
        // Procesar lógica
        // Enviar respuesta
        try {
            // Cierre del socket después del procesamiento
            cliente.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// En servidor principal
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
    Socket cliente = serverSocket.accept();
    Thread hiloCliente = new Thread(new PeticionHandler(cliente));
    hiloCliente.start();
}

Aquí se observa cómo cada solicitud entrante genera un nuevo hilo que procesa independientemente la petición sin bloquear otras conexiones, mejorando significativamente el rendimiento del servidor.

Ejemplo 3: Caso complejo - sincronización entre hilos en gestión bancaria

Pensemos en una aplicación bancaria donde múltiples clientes acceden simultáneamente a una cuenta compartida. Para evitar inconsistencias en el saldo tras depósitos o retiros concurrentes, se emplean mecanismos de sincronización.

public class CuentaBancaria {
    private double saldo;

    public CuentaBancaria(double saldoInicial) {
        this.saldo = saldoInicial;
    }

    public synchronized void depositar(double cantidad) {
        saldo += cantidad;
        System.out.println("Depósito: " + cantidad + ", Saldo actual: " + saldo);
    }

    public synchronized void retirar(double cantidad) throws Exception {
        if (saldo >= cantidad) {
            saldo -= cantidad;
            System.out.println("Retiro: " + cantidad + ", Saldo actual: " + saldo);
        } else {
            throw new Exception("Fondos insuficientes");
        }
    }

    public double getSaldo() {
        return saldo;
    }
}

public class Cliente extends Thread {
    private CuentaBancaria cuenta;

    public Cliente(CuentaBancaria cuenta) {
        this.cuenta = cuenta;
    }

    public void run() {
        try {
            cuenta.depositar(100);
            Thread.sleep(100);
            cuenta.retirar(50);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// Uso
public class SimulacionBancaria {
    public static void main(String[] args) throws InterruptedException {
        CuentaBancaria cuenta = new CuentaBancaria(500);
        Cliente c1 = new Cliente(cuenta);
        Cliente c2 = new Cliente(cuenta);
        c1.start();
        c2.start();
        c1.join();
        c2.join();
        System.out.println("Saldo final: " + cuenta.getSaldo());
    }
}

A través del método synchronized, se garantiza que las operaciones sobre el saldo sean atómicas y coherentes incluso cuando múltiples hilos acceden simultáneamente.

4. Análisis y Consideraciones Especiales

El empleo correcto de hilos requiere atención a diversos aspectos críticos:

• Sincronización adecuada: evitar condiciones de carrera mediante mecanismos como synchronized, semáforos o bloques críticos.
• Manejo eficiente: crear un número controlado de hilos mediante pools o gestores especializados para no saturar los recursos del sistema.
• Error handling: gestionar excepciones específicas relacionadas con la concurrencia para mantener la estabilidad del sistema.
• Evitación de deadlocks: diseñar cuidadosamente las dependencias entre hilos para prevenir bloqueos mutuos irreversibles.
• Tendencias actuales: uso creciente de frameworks asíncronos, programación reactiva y modelos basados en eventos que optimizan aún más el empleo de hilos en entornos empresariales complejos.

No obstante, también existen limitaciones inherentes al uso intensivo de hilos: sobrecarga por creación excesiva, dificultad para depurar errores concurrenciales y problemas relacionados con sincronización ineficaz. Por ello, es recomendable emplear patrones probados como pools gestionados por frameworks especializados o librerías modernas que abstraen estos detalles complejos.

5. Síntesis y Conceptos Clave

• Hilo (thread): Nueva unidad básica de ejecución dentro del proceso que permite realizar tareas concurrentes o paralelas.
• Sistema multihilo: Arquitectura que permite ejecutar múltiples hilos simultáneamente para mejorar rendimiento y capacidad reactiva.
• Sistema operativo:: Proporciona primitivas para gestionar la planificación y sincronización entre hilos.
• Síncronización:: Técnicas para coordinar accesos concurrentes a recursos compartidos evitando condiciones indeseadas.
• Pools o grupos de hilos:: Mecanismos que gestionan automáticamente la creación y reutilización eficiente de hilos para optimizar recursos.
• Manejo correcto:: Uso adecuado de mecanismos como synchronized, semáforos o futuras librerías especializadas para garantizar estabilidad y rendimiento.
• Error común:: Creación indiscriminada o mala sincronización puede causar condiciones peligrosas como deadlocks o starvation.
• Evolución tecnológica:: Tendencias hacia modelos asíncronos y reactivos que minimizan el uso explícito de hilos tradicionales mediante abstracciones modernas.

Cada uno de estos conceptos resulta fundamental para comprender cómo implementar eficazmente aplicaciones orientadas a objetos con capacidades multihilo robustas y eficientes, contribuyendo al desarrollo profesional en gestión empresarial tecnológica avanzada.