A continuación se describe seis ejercicios sencillos que abordan los temas de introducción a la programación concurrente, conceptos de programación concurrente, arquitecturas paralelas y distribuidas, así como algoritmos paralelos y distribuidos.

• Escribe un programa en el lenguaje de programación de tu elección que cree dos hilos. Cada hilo debe imprimir un mensaje simple, como “Hola desde Hilo 1” y “Hola desde Hilo 2”.
• Modifica el programa anterior para que ambos hilos intenten acceder y modificar una variable compartida. Utiliza un mecanismo de exclusión mutua (por ejemplo, mutex) para garantizar que solo un hilo pueda modificar la variable a la vez.
• Crea un programa que simule la producción y el consumo de un recurso compartido utilizando monitores. Puedes elegir un escenario simple, como un productor que agrega elementos a un búfer y un consumidor que los retira.
• Diseña un programa que utilice semáforos para sincronizar la ejecución de tres hilos. Cada hilo debe imprimir un mensaje en un orden específico, por ejemplo, “Hilo 1”, “Hilo 2” y “Hilo 3” en ese orden.
• Desarrolla un programa MPI simple en el que un proceso maestro envíe un mensaje a varios procesos esclavos, y estos procesos esclavos respondan al maestro. Puedes usar funciones MPI como MPI_Send y MPI_Recv.
• Implementa un problema clásico de productor-consumidor utilizando hilos y semáforos. El productor debe agregar elementos a un búfer compartido, y el consumidor debe retirarlos. Utiliza semáforos para evitar condiciones de carrera.

Estos ejercicios están diseñados para abordar conceptos básicos en hilos, exclusión mutua, monitores, semáforos y MPI. Se pueden adaptar al lenguaje de programación que se este utilizando.

La entrada Ejercicios | Hilos se publicó primero en Frexus.

Una planta de manufactura se enfrenta al desafío de integrar sistemas heterogéneos utilizados en diferentes etapas del proceso de producción. Cada sistema controla un componente específico del proceso y utiliza tecnologías diversas, como sistemas de control de procesos, sistemas de gestión de calidad y sistemas de monitoreo de maquinaria.

La falta de interoperabilidad entre estos sistemas impide una comunicación eficiente y la recopilación de datos en tiempo real. Los datos críticos para la toma de decisiones están dispersos en silos, lo que dificulta la optimización de la producción y la detección temprana de problemas.

Se decide implementar una arquitectura basada en CORBA para facilitar la comunicación entre los sistemas heterogéneos y permitir el intercambio de información en tiempo real.

Pasos de Implementación:

1. Definición de Interfaces en IDL: Se realiza un análisis de los datos que deben intercambiarse entre los sistemas y se define una interfaz en IDL que describa cómo se estructurarán y transmitirán estos datos.
2. Generación de Stubs y Esqueletos: Utilizando el compilador IDL, se generan automáticamente stubs y esqueletos en los lenguajes de programación utilizados en cada sistema.
3. Desarrollo de Servidores y Clientes CORBA: Se implementan servidores CORBA en cada sistema para exponer las funcionalidades y datos relevantes. Los clientes CORBA se desarrollan para acceder a estos servicios y datos.
4. Integración y Pruebas: Se integran los sistemas utilizando CORBA como middleware. Se realizan pruebas exhaustivas para garantizar la correcta comunicación entre los sistemas y la precisión en la transferencia de datos.
5. Resultados:
   • Optimización de la Producción: La comunicación eficiente entre sistemas permite una optimización más efectiva de la producción al coordinar y sincronizar las operaciones en tiempo real.
   • Detección Temprana de Problemas: La recopilación en tiempo real de datos de múltiples sistemas facilita la detección temprana de problemas, lo que permite tomar medidas correctivas antes de que afecten significativamente la producción.
   • Acceso Centralizado a Datos: La implementación de CORBA proporciona un acceso centralizado a datos críticos, eliminando los silos de información y mejorando la toma de decisiones.
   • Escalabilidad y Mantenimiento: La arquitectura basada en CORBA demuestra ser escalable y facilita el mantenimiento, ya que la adición de nuevos sistemas o la actualización de existentes se puede realizar de manera más eficiente.

Cuestiones para analizar

1. Pregunta 1:
   • ¿Cómo ayudó la implementación de CORBA en la planta de manufactura a superar la falta de interoperabilidad entre los sistemas heterogéneos utilizados en diferentes etapas del proceso de producción?
2. Pregunta 2:
   • ¿Cuáles fueron los beneficios clave de utilizar CORBA en términos de optimización de la producción y coordinación de operaciones en tiempo real?
3. Pregunta 3:
   • ¿Cómo contribuyó la arquitectura basada en CORBA a la detección temprana de problemas en la planta de manufactura?
4. Pregunta 4:
   • ¿De qué manera CORBA facilitó el acceso centralizado a datos críticos y eliminó los silos de información en la planta?
5. Pregunta 5:
   • ¿Cómo demostró la implementación de CORBA ser escalable y facilitar el mantenimiento en el entorno industrial de la planta?
6. Pregunta 6:
   • ¿Cuál fue el impacto general de la implementación de CORBA en la eficiencia operativa y la toma de decisiones informada en la planta de manufactura?

Este caso de estudio ilustra cómo la implementación de CORBA puede resolver problemas de integración en entornos industriales complejos, mejorando la eficiencia operativa y facilitando la toma de decisiones informada.

La entrada Integración de Sistemas en una Planta de Manufactura con CORBA se publicó primero en Frexus.

CORBA, “Common Object Request Broker Architecture” (Arquitectura Común de Buscador de Objetos), proporciona un marco para el desarrollo de sistemas distribuidos que pueden involucrar operaciones concurrentes. Aunque no se centra exclusivamente en la programación concurrente, su capacidad para facilitar la comunicación y la interoperabilidad entre objetos distribuidos contribuye a la construcción de sistemas que operan de manera concurrente en entornos distribuidos.

Este es un ejemplo sencillo de cómo usar CORBA en un entorno distribuido. En este caso, se debe de imaginar un sistema donde tenemos un servidor que proporciona servicios matemáticos simples y un cliente que utiliza estos servicios.

Definición de la Interfaz en IDL

Se debe de comenzar definiendo la interfaz en IDL (Interface Definition Language). Suponga que se quiere realizar operaciones matemáticas básicas.

// MathOperations.idl
module MathOperations {
  interface Calculator {
    double add(in double num1, in double num2);
    double subtract(in double num1, in double num2);
    double multiply(in double num1, in double num2);
    double divide(in double num1, in double num2);
  };
};

Generación de Stubs y Esqueletos

Se Usara un compilador IDL para generar los stubs y esqueletos correspondientes en los lenguajes de programación que se esta utilizando. Aquí se supone que se esta usando Java.

idlj -fall MathOperations.idl

Esto generará archivos como MathOperations/Calculator.java, que contendrán los stubs y esqueletos necesarios.

Implementación del Servidor

Creamos un servidor en Java que implementa la interfaz.

// MathServer.java
import MathOperations.*;

public class MathServer extends CalculatorPOA {
  public double add(double num1, double num2) {
    return num1 + num2;
  }

  public double subtract(double num1, double num2) {
    return num1 - num2;
  }

  public double multiply(double num1, double num2) {
    return num1 * num2;
  }

  public double divide(double num1, double num2) {
    if (num2 != 0) {
      return num1 / num2;
    } else {
      System.out.println("Error: Division by zero.");
      return 0;
    }
  }

  public static void main(String[] args) {
    org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
    try {
      org.omg.CORBA.Object objRef = orb.resolve_initial_references("RootPOA");
      POA rootpoa = POAHelper.narrow(objRef);
      rootpoa.the_POAManager().activate();

      MathServer mathServer = new MathServer();
      org.omg.CORBA.Object ref = rootpoa.servant_to_reference(mathServer);
      Calculator href = CalculatorHelper.narrow(ref);

      System.out.println("Math Server ready and waiting ...");
      orb.run();
    } catch (Exception e) {
      System.err.println("Error: " + e);
      e.printStackTrace(System.out);
    }
  }
}

Implementación del Cliente

Creamos un cliente que utiliza los servicios proporcionados por el servidor.

// MathClient.java
import MathOperations.*;

public class MathClient {
  public static void main(String[] args) {
    try {
      org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
      org.omg.CORBA.Object objRef = orb.string_to_object("corbaname::localhost:1050#Calculator");
      Calculator calculatorRef = CalculatorHelper.narrow(objRef);

      double num1 = 10.0;
      double num2 = 5.0;

      System.out.println("Adding: " + num1 + " + " + num2 + " = " + calculatorRef.add(num1, num2));
      System.out.println("Subtracting: " + num1 + " - " + num2 + " = " + calculatorRef.subtract(num1, num2));
      System.out.println("Multiplying: " + num1 + " * " + num2 + " = " + calculatorRef.multiply(num1, num2));
      System.out.println("Dividing: " + num1 + " / " + num2 + " = " + calculatorRef.divide(num1, num2));

      orb.shutdown(false);
    } catch (Exception e) {
      System.err.println("Error: " + e);
      e.printStackTrace(System.out);
    }
  }
}

Compilación y Ejecución

Compile y ejecute el servidor y el cliente. Asegúrate de tener el ORB en ejecución antes de ejecutar el cliente.

javac MathOperations/*.java MathServer.java MathClient.java
java MathServer -ORBInitialPort 1050 &
java MathClient -ORBInitialPort 1050

Este ejemplo básico ilustra cómo definir una interfaz en IDL, generar stubs y esqueletos, implementar un servidor y un cliente en Java, y cómo realizar operaciones remotas a través de CORBA. Hay que tener en cuenta que en un entorno de producción, se deben manejar aspectos como la gestión de excepciones, la seguridad y la configuración.

La entrada CORBA se publicó primero en Frexus.

CUDA (Compute Unified Device Architecture) es una tecnología de NVIDIA, por lo que si tienes una tarjeta gráfica de otro fabricante, como AMD, no sería compatible con CUDA. Se debe explorar alternativas, como OpenCL, que es un estándar abierto de programación para plataformas heterogéneas.

CUDA ha sido ampliamente adoptado en la comunidad de desarrollo, especialmente en áreas que se benefician de la capacidad de procesamiento masivamente paralelo de las GPUs. Además, otras compañías y proyectos han desarrollado tecnologías similares, pero CUDA es específico de las GPUs de NVIDIA.

A continuación se tiene un ejemplo sencillo en CUDA que realiza la suma de dos vectores. Este ejemplo se puede ejecutar en una GPU compatible con CUDA.

Código

#include <stdio.h>

// Kernel CUDA para sumar dos vectores
__global__ void vectorSum(float *a, float *b, float *result, int size) {
    int index = blockIdx.x * blockDim.x + threadIdx.x;
    if (index < size) {
        result[index] = a[index] + b[index];
    }
}

int main() {
    const int size = 1024;  // Tamaño de los vectores
    const int threadsPerBlock = 256;
    const int blocksPerGrid = (size + threadsPerBlock - 1) / threadsPerBlock;

    // Declaración de vectores en el host
    float hostVectorA[size], hostVectorB[size], hostResult[size];

    // Inicialización de los vectores en el host
    for (int i = 0; i < size; ++i) {
        hostVectorA[i] = i;
        hostVectorB[i] = 2 * i;
    }

    // Declaración de punteros para los vectores en el dispositivo (GPU)
    float *deviceVectorA, *deviceVectorB, *deviceResult;

    // Reserva de memoria en el dispositivo
    cudaMalloc((void **)&deviceVectorA, size * sizeof(float));
    cudaMalloc((void **)&deviceVectorB, size * sizeof(float));
    cudaMalloc((void **)&deviceResult, size * sizeof(float));

    // Copia de datos desde el host al dispositivo
    cudaMemcpy(deviceVectorA, hostVectorA, size * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(deviceVectorB, hostVectorB, size * sizeof(float), cudaMemcpyHostToDevice);

    // Lanzamiento del kernel CUDA
    vectorSum<<<blocksPerGrid, threadsPerBlock>>>(deviceVectorA, deviceVectorB, deviceResult, size);

    // Copia de resultados desde el dispositivo al host
    cudaMemcpy(hostResult, deviceResult, size * sizeof(float), cudaMemcpyDeviceToHost);

    // Impresión de resultados
    for (int i = 0; i < size; ++i) {
        printf("%f + %f = %f\n", hostVectorA[i], hostVectorB[i], hostResult[i]);
    }

    // Liberación de memoria en el dispositivo
    cudaFree(deviceVectorA);
    cudaFree(deviceVectorB);
    cudaFree(deviceResult);

    return 0;
}

Este programa realiza la suma de dos vectores en paralelo utilizando. Se debe de tener en cuenta que este es un ejemplo básico y que el desarrollo puede involucrar consideraciones adicionales, como la optimización del tamaño de los bloques y la gestión de la memoria en el dispositivo.

Bibliotecas en python

Para ejecutarse desde Python, existen varias bibliotecas y herramientas que permiten integrarlas en programas escritos en Python

PyCUDA

PyCUDA es una biblioteca que proporciona enlaces de Python para CUDA. Permite escribir y aprovechar las capacidades de cómputo en paralelo de las GPUs de NVIDIA. Se puede instalar PyCUDA utilizando pip

pip install pycuda

Numba

Numba es una biblioteca de Python que permite la compilación JIT (Just-In-Time) de funciones Python para ejecución en GPU. Puedes utilizar la funcionalidad @cuda.jit para decorar funciones que se ejecutarán en la GPU.

from numba import cuda

@cuda.jit
def vector_sum(a, b, result):
    idx = cuda.grid(1)
    if idx < len(a):
        result[idx] = a[idx] + b[idx]

CuPy

CuPy es una biblioteca similar a NumPy pero diseñada para ejecutarse en GPU. Proporciona una interfaz familiar para realizar operaciones en GPU y puede ser una alternativa eficiente para cálculos numéricos.

import cupy as cp

# Crear arrays en GPU
a_gpu = cp.array([1, 2, 3])
b_gpu = cp.array([4, 5, 6])

# Realizar la suma en GPU
result_gpu = a_gpu + b_gpu

# Transferir el resultado de vuelta a la CPU si es necesario
result_cpu = cp.asnumpy(result_gpu)

Estas bibliotecas permiten integrar código CUDA directamente en programas Python, facilitando el desarrollo de aplicaciones de cómputo en paralelo. Hay que tener en cuenta que, al utilizarlas en Python, aún se necesitará tener instalado el Toolkit de CUDA de NVIDIA y controladores compatibles con tu GPU.

La entrada CUDA se publicó primero en Frexus.

Estos ejercicios están diseñados para abordar diversos aspectos, desde la comunicación hasta la coordinación de procesos. Se puede usar cualquier lenguaje de programación.

Ejercicios

• Implementa un programa distribuido donde dos procesos (A y B) se comuniquen enviándose mensajes simples.
• Desarrolla un sistema distribuido que realice una tarea coordinada entre tres procesos, donde cada proceso realiza una parte específica de la tarea y comparten resultados.
• Crea un programa que utilice algún mecanismo de sincronización distribuida (por ejemplo, semáforos distribuidos) para garantizar el acceso seguro y sincronizado a un recurso compartido.
• Modifica uno de los ejercicios anteriores para incorporar algún mecanismo de tolerancia a fallos. Puedes simular fallos y observar cómo el sistema responde.
• Desarrolla un programa que demuestre la escalabilidad en un entorno distribuido. A medida que se agregan más nodos, la capacidad del sistema para manejar la carga de trabajo debe aumentar.
• Crea un sistema distribuido que distribuya tareas entre múltiples nodos para procesar en paralelo. Asegúrate de que los resultados de las tareas paralelas se recojan y combinen adecuadamente.

Estos ejercicios están diseñados para proporcionar práctica en conceptos clave de programación distribuida y concurrente.

Si eres nuevo en la programación distribuida, es posible que encuentres ciertos desafíos al principio, pero estos ejercicios están diseñados para ser accesibles y educativos. Se recomienda abordarlos en orden y, si es necesario, buscar recursos adicionales o consultar la documentación relacionada con las tecnologías que se este utilizando.

La entrada Ejercicios | programación distribudia se publicó primero en Frexus.

la programación distribuida es esencial en entornos modernos donde la escalabilidad, la redundancia y la tolerancia a fallos son fundamentales. Permite a los desarrolladores construir sistemas más flexibles y eficientes al aprovechar los recursos distribuidos de manera efectiva. A continuación se muestra unos ejemplos de su aplicación

Ejemplo: Calculo distribuido.

En este ejemplo simple de programación distribuida se utiliza Python y la biblioteca multiprocessing. Se simula un cálculo distribuido de la suma de elementos en una lista entre varios procesos en un sistema multicore.

Código

import multiprocessing

# Función para sumar elementos en una porción de la lista
def suma_parcial(lista, inicio, fin):
    suma_parcial = sum(lista[inicio:fin])
    return suma_parcial

if __name__ == "__main__":
    # Datos de ejemplo (lista de números)
    datos = list(range(1, 101))

    # Dividir la lista en varias partes
    num_procesos = 4
    longitud_sublista = len(datos) // num_procesos
    sublistas = [(i * longitud_sublista, (i + 1) * longitud_sublista) for i in range(num_procesos)]

    # Crear procesos y calcular sumas parciales en paralelo
    procesos = []
    for inicio, fin in sublistas:
        proceso = multiprocessing.Process(target=suma_parcial, args=(datos, inicio, fin))
        proceso.start()
        procesos.append(proceso)

    # Esperar a que todos los procesos terminen
    for proceso in procesos:
        proceso.join()

    # Recopilar resultados
    sumas_parciales = [proceso.exitcode for proceso in procesos]

    # Calcular la suma total
    suma_total = sum(sumas_parciales)

    print("Lista completa:", datos)
    print("Suma total distribuida:", suma_total)

Explicación

Este código divide una lista de números en partes y calcula la suma de cada parte en paralelo utilizando múltiples procesos. Cada proceso suma una porción de la lista, y al final, las sumas parciales se suman para obtener el resultado total. Este es un ejemplo simple de cómo se puede distribuir una tarea entre varios procesos para mejorar el rendimiento en un entorno multicore. En un entorno de programación distribuida a mayor escala, se podrían usar técnicas más avanzadas y herramientas específicas para la programación distribuida, como MPI o Apache Spark.

Ejemplo 2: Comunicación entre procesos

En este ejemplo se utiliza sockets en Python para implementar una comunicación simple entre dos procesos en diferentes máquinas, lo que refleja una situación de programación distribuida. Suponga que se tiene dos máquinas A y B, y se quiere que un proceso en la máquina A envíe un mensaje a un proceso en la máquina B. A continuación el código recomendado.

Código (servidor en máquina B)

import socket

# Configurar el servidor
host = '0.0.0.0'  # Escucha en todas las interfaces
puerto = 12345

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as servidor:
    servidor.bind((host, puerto))
    servidor.listen()

    print(f"Servidor escuchando en {host}:{puerto}")

    conexion, direccion = servidor.accept()

    with conexion:
        print(f"Conexión establecida desde {direccion}")

        # Recibir y mostrar el mensaje
        mensaje_recibido = conexion.recv(1024).decode('utf-8')
        print(f"Mensaje recibido: {mensaje_recibido}")

Código (cliente en la máquina A):

import socket

# Configurar el cliente
host_servidor = 'dirección_IP_de_B'  # Cambiar a la dirección IP de la máquina B
puerto_servidor = 12345

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as cliente:
    cliente.connect((host_servidor, puerto_servidor))

    # Enviar un mensaje al servidor
    mensaje = "Hola desde el cliente"
    cliente.sendall(mensaje.encode('utf-8'))

print("Mensaje enviado exitosamente.")

Explicación

Este ejemplo ilustra la comunicación básica entre dos procesos en máquinas diferentes mediante sockets. Se puede ejecutar el servidor en la máquina B y el cliente en la máquina A. Se debe asegurar de reemplazar ‘dirección_IP_de_B’ con la dirección IP real de la máquina B.

Esta práctica refleja un escenario de programación distribuida donde los procesos pueden ejecutarse en diferentes máquinas y comunicarse a través de la red. En entornos más complejos, se podría utilizar bibliotecas específicas de programación distribuida como ZeroMQ, RabbitMQ, o incluso MPI

La entrada Distribuida se publicó primero en Frexus.

Message Passing Interface (MPI) es un estándar para la programación paralela o distribuida, que permite a múltiples procesos (que pueden estar en diferentes computadoras) comunicarse entre sí mediante el envío y recepción de mensajes.

Se puede integrarse con lenguajes orientados a objetos como C++ o Python.

• Aplicación típica: programación de alto rendimiento (HPC), como simulaciones científicas o cálculos complejos en clústeres de computadoras.
• Ejemplo en C++ con MPI: Usar MPI_Send() y MPI_Recv() para enviar datos entre nodos de una red.

MPI es particularmente útil en el ámbito de la programación concurrente cuando se trata de desarrollar aplicaciones que requieren un alto rendimiento y escalabilidad en sistemas distribuidos.

aquí tienes un ejemplo simple de cómo usar MPI en C para realizar una suma colectiva en un clúster de procesadores:

Código

#include <stdio.h>
#include <mpi.h>

int main(int argc, char** argv) {
    // Inicializar el entorno MPI
    MPI_Init(&argc, &argv);

    // Obtener el rango y el tamaño del comunicador
    int rank, size;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    // Definir un array de números en cada proceso
    int local_numbers[3] = {rank + 1, rank + 2, rank + 3};
    int global_sum[3];

    // Realizar una suma colectiva de los números
    MPI_Allreduce(local_numbers, global_sum, 3, MPI_INT, MPI_SUM, MPI_COMM_WORLD);

    // Imprimir los resultados
    printf("Proceso %d: Números locales [%d, %d, %d], Suma global [%d, %d, %d]\n",
           rank, local_numbers[0], local_numbers[1], local_numbers[2],
           global_sum[0], global_sum[1], global_sum[2]);

    // Finalizar el entorno MPI
    MPI_Finalize();

    return 0;
}

Este programa MPI realiza la inicialización del entorno MPI, obtiene el rango y el tamaño del comunicador, y luego define un conjunto de números locales en cada proceso. Luego, utiliza la función MPI_Allreduce para realizar una suma colectiva de estos números y obtener la suma global, que se imprime en cada proceso.

Para compilar y ejecutar el programa en un clúster de procesadores usando, por ejemplo, el compilador mpicc:

mpicc ejemplo_mpi.c -o ejemplo_mpi
mpiexec -n 4 ./ejemplo_mpi

Este ejemplo utiliza Message Passing Interfacpara distribuir la carga de trabajo y realizar una operación colectiva, la suma, entre todos los procesos en el clúster. Cada proceso tiene un conjunto de números locales, y el resultado final es la suma global de todos estos conjuntos.

La entrada MPI se publicó primero en Frexus.

Los monitor son una herramienta valiosa en programación concurrente y han sido ampliamente adoptados en diversos contextos para gestionar la concurrencia de manera segura y eficiente.

Suponga que se quiere implementar un contador que puede ser incrementado y decrementado por varios hilos simultáneamente, pero se debe asegurar de que estas operaciones sean atómicas y que siempre se respete la exclusión mutua.

Codificación

import threading

class MonitorContador:
    def __init__(self):
        self.valor = 0
        self.mutex = threading.Lock()

    def incrementar(self):
        with self.mutex:
            self.valor += 1

    def decrementar(self):
        with self.mutex:
            self.valor -= 1

    def obtener_valor(self):
        with self.mutex:
            return self.valor

# Crear una instancia del monitor
contador_monitor = MonitorContador()

# Definir una función que incrementa el contador
def aumentar_contador():
    for _ in range(1000000):
        contador_monitor.incrementar()

# Definir una función que decrementa el contador
def disminuir_contador():
    for _ in range(1000000):
        contador_monitor.decrementar()

# Crear hilos para incrementar y decrementar el contador
hilo_aumentar = threading.Thread(target=aumentar_contador)
hilo_disminuir = threading.Thread(target=disminuir_contador)

# Iniciar los hilos
hilo_aumentar.start()
hilo_disminuir.start()

# Esperar a que ambos hilos terminen
hilo_aumentar.join()
hilo_disminuir.join()

# Obtener el valor final del contador desde el monitor
valor_final = contador_monitor.obtener_valor()
print("Valor final del contador:", valor_final)

Explicación

En este ejemplo, la clase MonitorContador encapsula el contador y los métodos (incrementar, decrementar, obtener_valor) que operan sobre él. Se utiliza un cerrojo (mutex) para garantizar la exclusión mutua alrededor de las operaciones críticas. Los dos hilos (hilo_aumentar y hilo_disminuir) realizan incrementos y decrementos en paralelo, pero gracias al monitor, estas operaciones son seguras y el valor final del contador reflejará la suma y resta correctamente.

La entrada Monitor se publicó primero en Frexus.

La programación concurrente, esencial en entornos de desarrollo modernos, involucra la ejecución simultánea de múltiples hilos o procesos para mejorar la eficiencia y la capacidad de respuesta de un programa.

Conceptos clave como la exclusión mutua, las regiones críticas y la sincronización juegan un papel fundamental. La exclusión mutua asegura que solo un hilo acceda a un recurso compartido en un momento dado, evitando así condiciones de carrera y garantizando la coherencia de los datos. Las regiones críticas, por su parte, son secciones de código donde se accede y modifica información compartida, y se implementan para garantizar que estas operaciones críticas se realicen de manera atómica, sin interferencia de otros hilos. La sincronización, coordina la ejecución de hilos para evitar conflictos y lograr un comportamiento predecible, utilizando mecanismos como cerrojos, variables de condición y semáforos. Estos conceptos son esenciales para desarrollar aplicaciones robustas y eficientes en entornos concurrentes. A continuación se muestra unos ejemplos

Ejemplo de exclusión mutua

Supongamos que se tiene una variable global compartida llamada contador. Se quiere garantizar que varios hilos puedan incrementar este contador sin que se pierdan actualizaciones debido a condiciones de carrera.

import threading

contador = 0
mutex = threading.Lock()

def incrementar():
    global contador
    for _ in range(1000000):
        with mutex:
            contador += 1

# Crear hilos
hilo_1 = threading.Thread(target=incrementar)
hilo_2 = threading.Thread(target=incrementar)

# Iniciar hilos
hilo_1.start()
hilo_2.start()

# Esperar a que ambos hilos terminen
hilo_1.join()
hilo_2.join()

print("Valor final del contador:", contador)

En este ejemplo, la exclusión mutua se logra utilizando un cerrojo (mutex). La sección crítica es la operación de incremento dentro del bucle. Solo un hilo puede ejecutar esta sección a la vez, asegurando que las actualizaciones al contador sean coherentes.

Ejemplo de de Región Crítica

Supongamos que se tiene una lista compartida y varios hilos que quieren agregar elementos a esta lista. Se necesita asegurar que la operación de agregar elementos se realice de manera segura.

import threading

lista_compartida = []
mutex = threading.Lock()

def agregar_elemento(elemento):
    with mutex:
        lista_compartida.append(elemento)

# Crear hilos
hilo_1 = threading.Thread(target=agregar_elemento, args=("A",))
hilo_2 = threading.Thread(target=agregar_elemento, args=("B",))

# Iniciar hilos
hilo_1.start()
hilo_2.start()

# Esperar a que ambos hilos terminen
hilo_1.join()
hilo_2.join()

print("Lista final:", lista_compartida)

Aquí, la región crítica es la operación de agregar elementos a la lista. El cerrojo (mutex) garantiza que solo un hilo pueda realizar esta operación a la vez, evitando problemas de concurrencia.

Ejemplo de Sincronización

Suponga que se tiene dos hilos: uno para imprimir números pares y otro para imprimir números impares en orden. Se Necesita sincronizarlos para asegurar que impriman alternadamente en orden.

import threading

mutex = threading.Lock()
condicion = threading.Condition()

def imprimir_pares():
    with mutex:
        for i in range(0, 10, 2):
            print(i)
            condicion.notify()
            condicion.wait()

def imprimir_impares():
    with mutex:
        for i in range(1, 10, 2):
            print(i)
            condicion.notify()
            condicion.wait()

# Crear hilos
hilo_pares = threading.Thread(target=imprimir_pares)
hilo_impares = threading.Thread(target=imprimir_impares)

# Iniciar hilos
hilo_pares.start()
hilo_impares.start()

# Esperar a que ambos hilos terminen
hilo_pares.join()
hilo_impares.join()

Aquí, se utiliza un objeto de condición (condicion) para sincronizar los hilos. La función notify() señala al otro hilo que puede imprimir, mientras que wait() hace que un hilo espere hasta que sea notificado por el otro. Esto asegura que los números pares e impares se impriman alternadamente en orden.

La entrada Exclusión, sincronización y región se publicó primero en Frexus.

Ejercicios

• Contador Concurrente
  • Escribe un programa que utilice dos hilos para incrementar y decrementar un contador compartido. Asegúrate de manejar adecuadamente la exclusión mutua para evitar condiciones de carrera.
• Imprimir en Orden
  • Crea tres hilos que impriman “Uno”, “Dos” y “Tres”, respectivamente, en orden. Asegúrate de que cada hilo espere al hilo anterior antes de imprimir su número.
• Productor-Consumidor
  • Implementa un problema de productor-consumidor utilizando dos hilos productores y dos hilos consumidores. Utiliza una cola compartida para la comunicación entre productores y consumidores.

Codificación

Solución 1: Contador Concurrente en Python

import threading
import time

contador = 0
mutex = threading.Lock()

def incrementar():
    global contador
    for _ in range(1000000):
        with mutex:
            contador += 1

def decrementar():
    global contador
    for _ in range(1000000):
        with mutex:
            contador -= 1

# Crear hilos
hilo_incrementar = threading.Thread(target=incrementar)
hilo_decrementar = threading.Thread(target=decrementar)

# Iniciar hilos
hilo_incrementar.start()
hilo_decrementar.start()

# Esperar a que ambos hilos terminen
hilo_incrementar.join()
hilo_decrementar.join()

print("Valor final del contador:", contador)

Explicación

• Se utiliza un contador compartido (contador) que dos hilos (incrementar y decrementar) modifican simultáneamente.
• Se utiliza un cerrojo (mutex) para garantizar la exclusión mutua y evitar condiciones de carrera.
• Cada hilo realiza un millón de incrementos o decrementos dentro de la sección crítica (dentro del with mutex).
• Al final, se imprime el valor final del contador.

Solución 2: Imprimir en Orden en Python

import threading

def imprimir_uno():
    print("Uno")

def imprimir_dos():
    print("Dos")

def imprimir_tres():
    print("Tres")

# Crear hilos
hilo_uno = threading.Thread(target=imprimir_uno)
hilo_dos = threading.Thread(target=imprimir_dos)
hilo_tres = threading.Thread(target=imprimir_tres)

# Iniciar hilos en orden
hilo_uno.start()
hilo_uno.join()

hilo_dos.start()
hilo_dos.join()

hilo_tres.start()
hilo_tres.join()

Explicación

• Se crean tres funciones (imprimir_uno, imprimir_dos, imprimir_tres) que imprimen diferentes mensajes.
• Se crean tres hilos (hilo_uno, hilo_dos, hilo_tres) asociados a cada función.
• Los hilos se inician y se espera a que cada uno termine antes de iniciar el siguiente, garantizando que los mensajes se impriman en orden.

Solución 3: Problema de Productor-Consumidor en Python

import threading
import queue
import time
import random

cola = queue.Queue(maxsize=5)

def productor():
    for i in range(5):
        item = f"Elemento-{i}"
        cola.put(item)
        print(f"Productor produce: {item}")
        time.sleep(random.uniform(0.1, 0.5))

def consumidor():
    while True:
        item = cola.get()
        print(f"Consumidor consume: {item}")
        time.sleep(random.uniform(0.2, 0.7))

# Crear hilos
hilo_productor_1 = threading.Thread(target=productor)
hilo_productor_2 = threading.Thread(target=productor)
hilo_consumidor_1 = threading.Thread(target=consumidor)
hilo_consumidor_2 = threading.Thread(target=consumidor)

# Iniciar hilos
hilo_productor_1.start()
hilo_productor_2.start()
hilo_consumidor_1.start()
hilo_consumidor_2.start()

Explicación

• Se utiliza una cola (cola) para la comunicación entre productores y consumidores.
• Hay dos thread productores (hilo_productor_1 y hilo_productor_2) y dos thread consumidores (hilo_consumidor_1 y hilo_consumidor_2).
• Los productores ponen elementos en la cola, mientras que los consumidores los sacan y los imprimen.
• El programa sigue ejecutándose indefinidamente, y los thread se pueden interrumpir manualmente.

La entrada Hilos se publicó primero en Frexus.