Ejercicio: Gestión de Tareas en un Taller de Reparaciones

Enunciado del Ejercicio

Un taller de reparaciones tiene un sistema para gestionar las tareas que deben ser realizadas en los vehículos. Las tareas son realizadas por un grupo de mecánicos que trabajan simultáneamente. El sistema debe garantizar que las tareas sean asignadas de manera ordenada y que ningún mecánico tome la misma tarea al mismo tiempo.

Objetivo

Diseñar un programa en Java que simule la asignación de tareas en un taller utilizando hilos. El programa debe gestionar una cola de tareas y un grupo de mecánicos que las procesen concurrentemente.


Requisitos Técnicos

  1. Clases necesarias:
    • Una clase Taller que gestione la cola de tareas pendientes.
    • Una clase Mecanico que represente a los hilos que ejecutan las tareas.
  2. Gestión de tareas:
    • Utiliza una estructura como Queue para gestionar las tareas pendientes.
    • Los mecánicos toman una tarea de la cola y la procesan.
  3. Sincronización:
    • Usa mecanismos como synchronized o una estructura bloqueante para evitar conflictos al acceder a la cola de tareas.
  4. Ejemplo de ejecución:
    • Simula un taller con 10 tareas y 3 mecánicos.
    • Cada mecánico procesa una tarea y muestra un mensaje indicando qué tarea está realizando.
    • Cuando todas las tareas estén completadas, el programa debe terminar.

Estructura Base del Código

import java.util.LinkedList;
import java.util.Queue;

class Taller {
    private final Queue<String> tareas;

    public Taller() {
        tareas = new LinkedList<>();
    }

    public synchronized void agregarTarea(String tarea) {
        tareas.add(tarea);
        System.out.println("Nueva tarea agregada: " + tarea);
        notify(); // Notifica a los mecánicos que hay una nueva tarea
    }

    public synchronized String tomarTarea() throws InterruptedException {
        while (tareas.isEmpty()) {
            wait(); // Espera si no hay tareas disponibles
        }
        return tareas.poll(); // Toma y elimina la tarea de la cola
    }
}

class Mecanico implements Runnable {
    private final int id;
    private final Taller taller;

    public Mecanico(int id, Taller taller) {
        this.id = id;
        this.taller = taller;
    }

    @Override
    public void run() {
        try {
            while (true) {
                String tarea = taller.tomarTarea();
                System.out.println("Mecánico " + id + " está procesando: " + tarea);
                Thread.sleep(2000); // Simula el tiempo de reparación
                System.out.println("Mecánico " + id + " completó: " + tarea);
            }
        } catch (InterruptedException e) {
            System.out.println("Mecánico " + id + " finalizó su turno.");
            Thread.currentThread().interrupt();
        }
    }
}

public class SistemaTaller {
    public static void main(String[] args) throws InterruptedException {
        Taller taller = new Taller();

        // Crear e iniciar mecánicos
        for (int i = 1; i <= 3; i++) {
            new Thread(new Mecanico(i, taller)).start();
        }

        // Agregar tareas al taller
        for (int i = 1; i <= 10; i++) {
            taller.agregarTarea("Tarea " + i);
            Thread.sleep(500); // Simula el tiempo entre nuevas tareas
        }

        // Simular cierre del taller después de un tiempo
        Thread.sleep(15000);
        System.exit(0); // Termina el programa
    }
}

Requisitos de Salida

El programa debe mostrar mensajes indicando:

  1. La asignación de tareas a la cola.
  2. Los mecánicos tomando y completando tareas.

Ejemplo de salida:

Nueva tarea agregada: Tarea 1
Nueva tarea agregada: Tarea 2
Nueva tarea agregada: Tarea 3
Mecánico 1 está procesando: Tarea 1
Mecánico 2 está procesando: Tarea 2
Mecánico 3 está procesando: Tarea 3
Mecánico 1 completó: Tarea 1
Nueva tarea agregada: Tarea 4
Mecánico 1 está procesando: Tarea 4
...

Puntos de Evaluación

  1. Uso correcto de wait() y notify() para la sincronización.
  2. Gestión eficiente de la cola de tareas con estructuras como Queue.
  3. Correcta implementación de hilos para simular mecánicos concurrentes.
  4. Manejo de interrupciones para detener mecánicos de forma ordenada.

Este ejercicio combina el manejo de hilos, sincronización y estructuras de datos dinámicas, fundamentales en programación concurrente.

Deja un comentario

Información básica sobre protección de datos Ver más

  • Responsable: Tomas Gonzalez.
  • Finalidad:  Moderar los comentarios.
  • Legitimación:  Por consentimiento del interesado.
  • Destinatarios y encargados de tratamiento:  No se ceden o comunican datos a terceros para prestar este servicio.
  • Derechos: Acceder, rectificar y suprimir los datos.
  • Información Adicional: Puede consultar la información detallada en la Política de Privacidad.

error: Content is protected !!

Descubre más desde Tomás González: Formador y Desarrollador Web

Suscríbete ahora para seguir leyendo y obtener acceso al archivo completo.

Seguir leyendo

Este sitio web utiliza cookies, si necesitas más información puedes visitar nuestra política de privacidad    Ver
Privacidad