Pràctica 2: Programació de fils

Joan Puigcerver Ibáñez

j.puigcerveribanez@edu.gva.es

Llicència: CC BY-NC-SA 4.0

(Reconeixement - NoComercial - CompartirIgual) 🅭

Objectius¶

Desenvolupar aplicacions en Java que gestionen i creen diferents fils d'execució.

Entrega¶

L'entrega ha de complir els requisits següents:

Package: ud2.practices.
Nom de la classe: la classe on comença l'execució (main()) de cada exercici té com a nom el títol de l'exercici.
Format de l'eixida: ha de ser consistent amb el format demanat.
Lliurament: un fitxer .zip amb el contingut del package ud2.practices.
Repositori: el codi ha d'estar pujat a GitHub, al teu repositori del mòdul.
Etiqueta de GitHub: PracticeThreads ( Create a tag in a GitHub repository – StackOverflow).

`CollectiveTasks`¶

Package: ud2.practices.collectivetasks.

Les persones treballadores de l'empresa informàtica s'han adonat que la faena de les persones coordinadores (managers) només és assignar tasques i comprovar que s'han realitzat, i han decidit prescindir-ne.

Per gestionar les tasques, cada equip Team ha creat una borsa de tasques que s'han de realitzar. Cada persona empleada de l'equip agafa una tasca de la borsa i la realitza. Les tasques han de passar per dos estats abans de considerar-se finalitzades.

Crea el programa CollectiveTasks que simule la realització d'un projecte en el qual diferents equips realitzen les seues tasques sense necessitat de cap manager. Implementa els mètodes següents:

Task::work(): defineix com es completa una tasca. Ha d'obtindre el fil actual i fer que espere tants mil·lisegons com s'han definit en la tasca. A més, ha d'imprimir un missatge quan comença la tasca i quan acaba:
```
Pere: Starting task Main page design...
Pere: Finished task Main page design (2500 ms).
```
Task::test(): defineix com es prova una tasca. Ha d'obtindre el fil actual i fer que espere la meitat dels mil·lisegons definits en la tasca. A més, ha d'imprimir un missatge quan comença la prova i quan acaba:
```
Pere: Testing task Main page design...
Pere: Finished testing task Main page design (1250 ms).
```
EmployeeThread::run(): defineix el comportament de cada persona empleada. Ha d'obtindre la tasca següent a realitzar del seu equip Team:
- Si la Task no està completada:
  - Realitzar la tasca amb Task::work().
  - Una vegada completada, afegir la tasca a Task::testingTasks.
- Si la Task no està provada:
  - Provar la tasca amb Task::test().
  - Una vegada provada, afegir la tasca a Task::finishedTasks.
- Si la Task és null: ja s'han completat totes les tasques.
A més, ha de mostrar un missatge amb la tasca obtinguda:
```
Pere: Assigned to task Main page design.
Pere: No more pending tasks. Going home.
```
Team::getNextTask(): retorna la tasca següent que ha de realitzar l'equip. Retorna la primera tasca de unfinishedTasks. Si no en queden en aquesta llista, retorna la primera tasca de testingTasks. Si no en queden en cap llista, retorna null.
CollectiveTasks::main(): crea els equips i les tasques. Cal completar-lo perquè cada equip comence a treballar en les tasques assignades. Ha de mostrar el missatge següent quan tots els equips acaben les seues tasques:
```
Project finished! Every team has finished the assigned tasks.
```

Utilitza monitors per controlar els accessos als recursos compartits.

Cal modificar les definicions dels mètodes sensibles a problemes de concurrència utilitzant synchronized.

Codi font¶

CollectiveTasks.java

package ud2.practices.collectivetasks;

public class CollectiveTasks {
    public static void main(String[] args) {
        Team frontend = new Team("Frontend");
        frontend.addTask("Main page design", 2500);
        frontend.addTask("Shopping cart navigation bar", 5500);
        frontend.addTask("Breadcrumb", 1500);
        frontend.addTask("Profile page", 7500);
        frontend.addEmployee(new EmployeeThread("Pere"));
        frontend.addEmployee(new EmployeeThread("Maria"));

        Team backend = new Team("Backend");
        backend.addTask("Connect API to database", 3000);
        backend.addTask("Shopping API models", 4200);
        backend.addTask("API authentication", 2100);
        backend.addTask("Testing API", 5500);
        backend.addEmployee(new EmployeeThread("Anna"));
        backend.addEmployee(new EmployeeThread("Arnau"));

        Team database = new Team("Database");
        database.addTask("Relation Model", 5000);
        database.addTask("Define models in the database", 4200);
        database.addTask("Install DBMS", 3000);
        database.addTask("Views", 2800);
        database.addEmployee(new EmployeeThread("Mireia"));
        database.addEmployee(new EmployeeThread("Mar"));

        // TODO: Start all the teams and wait for them to finish their tasks

        System.out.println("Projecte acabat! Tots els equips han acabat les tasques assignades.");
    }
}

Team.java

package ud2.practices.collectivetasks;

import java.util.ArrayList;
import java.util.List;

public class Team {
    private final String name;
    private final List<EmployeeThread> employees;
    private final List<Task> unfinishedTasks;
    private final List<Task> testingTasks;
    private final List<Task> finishedTasks;

    public Team(String name) {
        this.name = name;
        employees = new ArrayList<>();
        unfinishedTasks = new ArrayList<>();
        testingTasks = new ArrayList<>();
        finishedTasks = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public List<EmployeeThread> getEmployees() {
        return employees;
    }

    public void addEmployee(EmployeeThread employee) {
        this.employees.add(employee);
        employee.setTeam(this);
    }

    public void addTask(String taskName, int taskDuration) {
        unfinishedTasks.add(new Task(taskName, taskDuration));
    }

    public Task getNextTask(){
        /**
         * TODO:
         * Get next Task from unfinishedTasks. If all unfinishedTaks are done,
         * get next Task from testingTasks.
         * The task must be deleted from the list when retrieved.
         * If all Tasks are done and tested, return null.
         */

        return null;
    }
}

EmployeeThread.java

package ud2.practices.collectivetasks;

import java.util.ArrayList;
import java.util.List;

public class EmployeeThread extends Thread{

    Team team;
    public EmployeeThread(String name) {
        super();
        this.setName(name);
        this.team = null;
    }

    public void setTeam(Team team) {
        this.team = team;
    }

    @Override
    public void run() {
        /*
         * TODO: Get next task from team.
         *
         * If the task needs to be done:
         *  - Do the task with work()
         *  - Add the task to testingTasks
         * If the task needs to be tested:
         *  - Test the task with test()
         *  - Add the task to finishedTasks
         * If the task is null:
         *  - All tasks are done. Exit.
         */

        System.out.printf("%s: Ha realitzat totes les tasques assignades.\n", this.getName());
    }
}

Task.java

package ud2.practices.collectivetasks;

public class Task {
    private final int duration;
    private final String name;
    private TaskStatus status;

    public Task(String name, int duration) {
        this.name = name;
        this.duration = duration;
        status = TaskStatus.UNFINISHED;
    }

    public int getDuration() {
        return duration;
    }

    public String getName() {
        return name;
    }

    public TaskStatus status() {
        return status;
    }

    public void setStatus(TaskStatus status) {
        this.status = status;
    }

    public void work(){
        Thread current = Thread.currentThread();
        System.out.printf("%s: Starting task %s...\n", current.getName(), this.name);

        // TODO: Do the task (sleep DURATION miliseconds)

        setStatus(TaskStatus.TESTING);
        System.out.printf("%s: Finished task %s (%d).\n", current.getName(), this.name, this.duration);
    }

    public void test(){
        Thread current = Thread.currentThread();
        System.out.printf("%s: Starting task %s...\n", current.getName(), this.name);

        // TODO: Do the task (sleep DURATION / 2 miliseconds)

        setStatus(TaskStatus.FINISHED);
        System.out.printf("%s: Finished task %s (%d).\n", current.getName(), this.name, this.duration);
    }
}

TaskStatus.java

package ud2.practices.collectivetasks;

public enum TaskStatus {
    UNFINISHED,
    TESTING,
    FINISHED
}

`SwimmingPool`¶

Package: ud2.practices.swimmingpool.

Crea el programa SwimmingPool que simule una piscina pública, on diferents persones poden accedir als recursos de la piscina simultàniament. Els recursos disponibles són:

Una piscina amb capacitat per a 10 persones.
Dutxes amb capacitat per a 3 persones.
Una zona per descansar.

Cada persona s'executa en un fil diferent i realitza les accions següents, que es repeteixen indefinidament:

Descansar entre 1 i 5 s, de manera aleatòria.
Dutxar-se (2 s).
Banyar-se entre 1 i 10 s, de manera aleatòria.

Pots generar nombres aleatoris amb ThreadLocalRandom.nextInt(int, int) – Oracle.

El programa principal ha d'esperar 1 minut i interrompre l'execució de totes les persones. Quan una persona canvie d'estat respecte a les accions anteriors, s'han de mostrar els missatges següents:

La persona està descansant:
```
Pere està descansant 4.2 segons.
```
La persona vol dutxar-se:
```
Pere vol dutxarse.
```
La persona està dutxant-se:
```
Pere està dutxant-se.
```
La persona ha acabat de dutxar-se:
```
Pere ha acabat de dutxar-se.
```
La persona espera per entrar a la piscina:
```
Pere vol nadar.
```
La persona està nadant:
```
Pere està nadant 2.3 segons.
```
La persona ha eixit de la piscina:
```
Pere ha eixit de la piscina.
```
La persona ha sigut expulsada de la piscina:
```
Pere ha abandonat les instal·lacions.
```

Codi font¶

SwimmingPool.java

package ud2.practices.swimmingpool;

import java.util.ArrayList;
import java.util.List;

public class SwimmingPool {
    // TODO: Add semaphores

    public SwimmingPool(int poolCapacity, int showersCapacity) {
        // TODO: Create semaphores
    }

    // TODO: create get() method for semaphores

    public static void main(String[] args) {
        SwimmingPool pool = new SwimmingPool(10, 3);
        String[] names = {
            "Andrès", "Àngel", "Anna", "Carles", "Enric",
            "Helena", "Isabel", "Joan", "Lorena", "Mar",
            "Maria", "Marta", "Míriam", "Nicolàs", "Òscar",
            "Paula", "Pere", "Teresa", "Toni", "Vicent"
        };
        List<PersonThread> persons = new ArrayList<>();
        for(String name : names) {
            // TODO: Create the threads and start them
        }

        // TODO: Wait 60 seconds and kick all persons

        // TODO: Wait for all persons to leave

        System.out.println("Tothom ha marxat de la piscina.");
    }
}

PersonThread.java

package ud2.practices.swimmingpool;

public class PersonThread extends Thread {
    private final SwimmingPool pool;

    public PersonThread(String name, SwimmingPool pool) {
        super(name);
        this.pool = pool;
    }

    /**
     * TODO: The persons rests between 1 and 5 seconds
     * @throws InterruptedException: if the thread is interrupted
     */
    public void rest() throws InterruptedException {
        int milis = 0;
        System.out.printf("%s està descansant %.2f segons.\n", getName(), milis / 1000.0);
    }

    /**
     * TODO: The persons takes a shower for 2 seconds
     * - Tries to get into a shower
     * - Takes a shower
     * - Leaves the showers
     * @throws InterruptedException: if the thread is interrupted
     */
    public void takeShower() throws InterruptedException {
        int milis = 2000;
        System.out.printf("%s vol dutxar-se.\n", getName());
        System.out.printf("%s està dutxant-se.\n", getName());
        System.out.printf("%s ha acabat de dutxar-se.\n", getName());
    }

    /**
     * TODO: The persons swims between 1 and 10 seconds
     * - Tries to get into the swimming pool
     * - Swims
     * - Leaves the swimming pool
     * @throws InterruptedException: if the thread is interrupted
     */
    public void swim() throws InterruptedException {
        int milis = 0;
        System.out.printf("%s vol nadar.\n", getName());
        System.out.printf("%s està nadant %.2f segons.\n", getName(), milis / 1000.0);
        System.out.printf("%s ha eixit de la piscina.\n", getName());
    }

    @Override
    public void run() {
        while(true) {
            // TODO: Rests
            // TODO: Takes a shower
            // TODO: Swims
        }
        // System.out.printf("%s ha abandonat les instal·lacions.\n", getName());
    }
}

`LyricsApp`¶

Package: ud2.practices.lyrics.

Crea el programa LyricsApp, un reproductor de lletres de cançons que simula com treballen els reproductors de música. El programa ha de crear dos fils diferents:

Player: reprodueix la cançó escollida. El reproductor mostra una paraula de la lletra cada mig segon (0,5 s).
Loader: s'encarrega de descarregar la cançó en segon pla. Aquest fil llig les lletres des del fitxer de text files/ud2/lyrics.txt.

El programa ha de seguir l'estructura bàsica de Producer/Consumer:

El fil Loader obté les línies del fitxer i les guarda en la llista de línies.
El fil Player obté les línies a mostrar a partir de la llista LyricsApp::lines i les mostra per pantalla.

Crea els mecanismes de sincronització necessaris perquè:

El fil Player espere que hi haja alguna línia disponible per poder reproduir-la.
El fil Loader notifique que ha llegit una línia.
No hi haja accessos simultanis a la llista LyricsApp::lines.

Codi font¶

LyricsApp.java

package ud2.practices.lyrics;

import java.util.ArrayList;
import java.util.List;

public class LyricsApp {
    private final Player player;
    private final Loader loader;
    private final List<String> lines;
    private boolean end;

    public LyricsApp(String filename) {
        player = new Player(this);
        loader = new Loader(this, filename);
        lines = new ArrayList<>();
        end = false;
    }

    public void setEnd(boolean end) {
        this.end = end;
    }
    public boolean ended(int i) {
        return end && i >= lines.size();
    }

    public boolean isLineAvailable(int i){
        return i < lines.size();
    }

    public String getLine(int i){
        return lines.get(i);
    }

    public int addLine(String line){
        lines.add(line);
        return lines.size() - 1;
    }

    public void start(){
        player.start();
        loader.start();
    }
    public void join() throws InterruptedException {
        player.join();
        loader.join();
    }
    public void interrupt() {
        player.interrupt();
        loader.interrupt();
    }

    public static void main(String[] args) {
        LyricsApp lyricsPlayer = new LyricsApp("files/ud2/lyrics.txt");
        lyricsPlayer.start();

        try {
            lyricsPlayer.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

Player.java

package ud2.practices.lyrics;

public class Player extends Thread {
    private final LyricsApp lyricsPlayer;
    private int lyricsIndex;

    public Player(LyricsApp lyricsPlayer) {
        this.lyricsPlayer = lyricsPlayer;
        lyricsIndex = 0;
    }

    public void playLine(int i) throws InterruptedException {
        String[] line = lyricsPlayer.getLine(i).split(" ");

        for (int j = 0; j < line.length; j++) {
            Thread.sleep(500);
            if(j == 0)
                System.out.printf("%d: ", i);
            else
                System.out.print(" ");
            System.out.print(line[j]);
        }
        System.out.println();
    }

    @Override
    public void run() {
        try {
            while(!lyricsPlayer.ended(lyricsIndex)){
                this.playLine(lyricsIndex);
                lyricsIndex++;
            }
        } catch (Exception e) {
            System.err.println(e.getMessage());
            lyricsPlayer.interrupt();
        }
    }
}

Loader.java

package ud2.practices.lyrics;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.concurrent.ThreadLocalRandom;

public class Loader extends Thread {
    private final LyricsApp lyricsPlayer;
    private final String filename;

    public Loader(LyricsApp lyricsPlayer, String filename) {
        this.lyricsPlayer = lyricsPlayer;
        this.filename = filename;
    }

    @Override
    public void run() {
        try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
            String line;
            while ((line = br.readLine()) != null) {
                Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 10000));
                int i = this.lyricsPlayer.addLine(line);
                System.err.printf(" (Line %d loaded) ", i);
            }
            this.lyricsPlayer.setEnd(true);
        } catch (Exception e) {
            System.err.println(e.getMessage());
            lyricsPlayer.interrupt();
        }
    }
}

📌 Aquest document pot quedar desactualitzat després d’imprimir-lo. Pots consultar la versió més recent a la pàgina web.

🌿 Abans d’imprimir aquest document, considera si és realment necessari. Redueix el consum de paper i ajuda a protegir el nostre entorn.

Pràctica 2: Programació de fils

Objectius¶

Entrega¶

CollectiveTasks¶

Codi font¶

SwimmingPool¶

Codi font¶

LyricsApp¶

Codi font¶

`CollectiveTasks`¶

`SwimmingPool`¶

`LyricsApp`¶