Práctica 1 — Repaso de Java y multihilos

Programas_P1/unam.fc.concurrent.practica1/src/module-info.java

/**
 * 
 */
/**
 * 
 */
module unam.fc.concurrent.practica1 {
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/AlwaysDesignToStop.java

package unam.fc.concurrent.practica1;
//Programa 5: Ejemplo de un contador que termina solo si el hilo principal lo detiene
//      El hilo principal es el que corre el programa en JVM.
//      El hilo A va a ejecutarse mientras done = true
//      

public class AlwaysDesignToStop {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        StopCounter counter = new StopCounter();
        Thread threadA = new Thread(counter);
        threadA.start();
        
        try{
            Thread.sleep(1500);
            //threadA.join();
        }catch(InterruptedException e) {
            System.out.println(e);
        }
        System.out.println("Running Thread: " + threadName);
        counter.stopcount();
    }

}
class StopCounter  implements Runnable{
    int count=0;
    boolean done = true;
    int increment() {
        count++;
        return count;
    }
    void stopcount() {
        this.done = false;
    }
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        while(this.done) {
            try{
                Thread.sleep(500);
                System.out.println("Running Thread: " + threadName + " increment to: " + increment());
            }catch(InterruptedException e) {
                System.out.println(e);
            }
            
        }
        
    }
    
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/CounterNaive.java

package unam.fc.concurrent.practica1;

public class CounterNaive {
    private int count=0;
    public int increment() {
        return this.count++;
    }
    public int getValue() {
        return this.count;
    }
    
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/DeterminanteConcurrente.java

package unam.fc.concurrent.practica1;
/*  Programa 10: Programa para obtener el determinante de una matriz de 3x3
 *  Es más paralelizable, pero nos benefician en el tiempo de ejecucon utilizar hilos?
*/

public class DeterminanteConcurrente extends Thread{
    static int determinante;
    static int n_prueba = 3;
    static int matriz_prueba[][] = { { 1, 2, 2 }, { 1, 0, -2 }, { 3, -1, 1 }};
    int num1, num2, num3, partial;
    
    public DeterminanteConcurrente(int num1, int num2, int num3) {
        this.num1 = num1;
        this.num2 = num2;
        this.num3 = num3;
    }
    
    public static int determinanteMatriz3x3(int matriz[][], int n_prueba) {
        int result = 0;
        DeterminanteConcurrente thr1 = new DeterminanteConcurrente(matriz[0][0], matriz[1][1], matriz[2][2]);
        DeterminanteConcurrente thr2 = new DeterminanteConcurrente(matriz[1][0], matriz[2][1], matriz[0][2]);
        DeterminanteConcurrente thr3 = new DeterminanteConcurrente(matriz[2][0], matriz[0][1], matriz[1][2]);
        DeterminanteConcurrente thr4 = new DeterminanteConcurrente(matriz[2][0], matriz[1][1], matriz[0][2]);
        DeterminanteConcurrente thr5 = new DeterminanteConcurrente(matriz[1][0], matriz[0][1], matriz[2][2]);
        DeterminanteConcurrente thr6 = new DeterminanteConcurrente(matriz[0][0], matriz[2][1], matriz[1][2]);
        thr1.start();
        thr2.start();
        thr3.start();
        thr4.start();
        thr5.start();
        thr6.start();
        try{
            thr1.join();
            thr2.join();
            thr3.join();
            thr4.join();
            thr5.join();
            thr6.join();
        }catch(InterruptedException e) {}
        result = thr1.partial + thr2.partial + thr3.partial - thr4.partial - thr5.partial - thr6.partial;
       
        return result;
    }
    
    public void run(){
        this.partial = this.num1 * this.num2 * this.num3;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        long startTime = System.nanoTime();
        determinante = determinanteMatriz3x3(matriz_prueba, n_prueba);
        long endTime = System.nanoTime();
        System.out.println("Program took " +
                (endTime - startTime) + "ns, result: " + determinante) ;

    }

}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/ExampleMultipleExtends.java

package unam.fc.concurrent.practica1;

//Programa 2: Ejemplo de un contador extendiendo la clase Thread
//      Acaban en distintos tiempos
//      Cada hilo crea su propia variable count porque son 3 objetos ThreadExtend1 distintos

public class ExampleMultipleExtends {

    public static void main(String[] args) {
        ThreadExtend1 threadA = new ThreadExtend1();
        ThreadExtend1 threadB = new ThreadExtend1();
        ThreadExtend1 threadC = new ThreadExtend1();
        threadA.start();
        threadB.start();
        threadC.start();
    }

}

class ThreadExtend1  extends Thread{
    int count=0;
    int increment() {
        count++;
        return count;
    }
    public void run() {
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        System.out.println("Running Thread " + threadName + " increment to: " + increment());
    }
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/ExampleMultipleExtends2.java

package unam.fc.concurrent.practica1;

//Programa 7: Ejemplo de un contador extendiendo la clase Thread
// Se crea un solo contador y se comparte a ThreadExtend2, asi que el contador es un objeto compartido
// Utilizamos join() para que se devuelva la cuenta final en la linea 23. 
// 
// Practica 2: Existe una condicion de carrera (race condition)
// Tiene una consistencia baja el contador

public class ExampleMultipleExtends2 {

    public static void main(String[] args) {
        CounterNaive counter = new CounterNaive();
        ThreadExtend2 threadA = new ThreadExtend2(counter);
        ThreadExtend2 threadB = new ThreadExtend2(counter);
        ThreadExtend2 threadC = new ThreadExtend2(counter);
        ThreadExtend2 threadD = new ThreadExtend2(counter);
        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
        try{
            threadA.join();
            threadB.join();
            threadC.join();
            threadD.join();
        }catch(InterruptedException e) {
            System.out.println(e);
        }
        System.out.println("Total " + counter.getValue());
    }

}
class ThreadExtend2  extends Thread{
    private CounterNaive counter = null;
    
    ThreadExtend2(){}
    ThreadExtend2(CounterNaive counter){
        this.counter = counter;
    }
    public void run() {
//      String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        //while(this.counter.getValue() < 10) {
        for(int i = 0; i < 10; i++) {
            this.counter.increment();
            try{
                Thread.sleep(100);
            }catch(InterruptedException e) {
                System.out.println(e);
            }
            
            //System.out.println("Running Thread " + threadName + " increment to: " + this.counter.increment());
        }
        //System.out.println("Running Thread " + threadName + " increment to: " + this.counter.increment());
    }
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/ExampleMultipleRunnable.java

package unam.fc.concurrent.practica1;

//Programa 3: Ejemplo de un contador implementando la interfaz Runnable
//   Acaban en distintos tiempos
//   Se crea un solo objeto Runnable y se comparte, count es una variable compartida

public class ExampleMultipleRunnable {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThreadRunnable1 myRunnable = new ThreadRunnable1();
        Thread threadA = new Thread(myRunnable);
        Thread threadB = new Thread(myRunnable);
        Thread threadC = new Thread(myRunnable);
        threadA.start();
        threadB.start();
        threadC.start();
    }

}

class ThreadRunnable1  implements Runnable{
    int count=0;
    int increment() {
        return count++;
    }
    int getCount() {
        return count;
    }
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        System.out.println("Running Thread Runnable " + threadName + " increment to: " + increment());
        
    }
    
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/ExampleMultipleRunnable2.java

package unam.fc.concurrent.practica1;
//Programa 8: Ejemplo de un contador implementando Runnable
//Se crea un solo contador y se comparte a ThreadExtend2, asi que el contador es un objeto compartido
//Los hilos se ejecutan en desorden y el resultado no es siempre: 1, 2, 3
public class ExampleMultipleRunnable2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CounterNaive counter = new CounterNaive();
        ThreadRunnable2 myRunnable = new ThreadRunnable2(counter);
        Thread threadA = new Thread(myRunnable);
        Thread threadB = new Thread(myRunnable);
        Thread threadC = new Thread(myRunnable);
        threadA.start();
        threadB.start();
        threadC.start();
    }

}

class ThreadRunnable2  implements Runnable{
    CounterNaive counter=null;
    ThreadRunnable2(){}
    ThreadRunnable2(CounterNaive counter){
        this.counter = counter;
    }
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        System.out.println("Running Thread Runnable " + threadName + " increment to: " + this.counter.increment());
    }
    
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/ExampleThreads.java

package unam.fc.concurrent.practica1;
import unam.fc.concurrent.practica1.ThreadExtends;
import unam.fc.concurrent.practica1.ThreadRunnable;
//Programa 1: Creacion de un hilo
//   Dos formas: Forma de creacion del Hilo A o forma de creacion del hilo B
//   Utiliza las clases: ThreadExtends y ThreadRunnable

public class ExampleThreads{
    public static void main(String[] args) {
        //threadA es un hilo que extiende la clase Thread
        ThreadExtends threadC = new ThreadExtends();
        ThreadExtends threadA= new ThreadExtends(); 
        //threadB es un hilo Thread al cual se le pasa una instancia de Runnable
        Thread threadB= new Thread(new ThreadRunnable()); 
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/FibonacciThreads.java

package unam.fc.concurrent.practica1;
/*  Programa 9: Fibonacci
 * Programa no muy paralelizable porque es recursivo, ademas de que crear muchos hilos hace un "overhead" en la memoria
*/
public class FibonacciThreads extends Thread{
    int n;
    int result;
    public FibonacciThreads(int n) {
        this.n = n;
    }
    
    public void run() {
        if((n==0)||(n==1)) result = 1;
        else {
            FibonacciThreads thr1 = new FibonacciThreads(n-1); 
            FibonacciThreads thr2 = new FibonacciThreads(n-2); 
            thr1.start();
            thr2.start();
            
            try{
                thr1.join();
                thr2.join();
            }catch(InterruptedException e) {}
            
            this.result = thr1.result + thr2.result;
            //System.out.println(this.result);
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int num = 10;
        FibonacciThreads thr0 = new FibonacciThreads(num);
        thr0.start();
        try{
            //threadA.join();
            thr0.join();
        }catch(InterruptedException e) {}
        System.out.println("The "+ num + "th number of the fibonacci series is: "+ thr0.result);
    }
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/MainThread.java

package unam.fc.concurrent.practica1;

//Programa 4: Ejemplo de un contador que no termina
//  El hilo principal es el que corre el programa en JVM.
//  El metodo run() no tiene fin, el hilo A nunca termina, entonces el programa no termina
//  El programa puede terminar si descomentas la linea 14, porque el hilo A se vuelve daemon

public class MainThread {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        Thread threadA = new Thread(new InfiniteCounter());
        //threadA.setDaemon(true);
        threadA.start();
        
        try{
            Thread.sleep(1500);
            //threadA.join();
        }catch(InterruptedException e) {
            System.out.println(e);
        }
        System.out.println("Running Thread: " + threadName);
    }

}
class InfiniteCounter  implements Runnable{
    int count=0;
    int increment() {
        count++;
        return count;
    }
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        while(true) {
            try{
                Thread.sleep(500);
                System.out.println("Running Thread: " + threadName + " increment to: " + increment());
            }catch(InterruptedException e) {
                System.out.println(e);
            }
            
        }
        
    }
    
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/ThreadExtends.java

package unam.fc.concurrent.practica1;
public class ThreadExtends  extends Thread{
    public void run() {
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        System.out.println("Running Thread that extends Thread class: " + threadName);
    }
    
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/ThreadRunnable.java

package unam.fc.concurrent.practica1;
//Clase que implementa la interfaz Runnable
public class ThreadRunnable implements Runnable{
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        System.out.println("Running Thread that implements Runnable interface: " + threadName);
    }
}

Programas_P1/unam.fc.concurrent.practica1/src/unam/fc/concurrent/practica1/UseJoin.java

package unam.fc.concurrent.practica1;

//Programa 6: Uso de join()
//      Si comentamos la lineas 34-49 el resultado es 0
//      Si solo comentamos la linea 35 el resultado es 01
//      Si solo comentamos la linea 36 el resultado es 11
//      El metodo A.join() permite que todo se congele hasta que termine el hilo A

public class UseJoin extends Thread{
    int rounds=0;
    int result=0;
    public UseJoin(int rounds) {
        this.rounds = rounds; 
    }
    
    public void run() {
        String threadName = Thread.currentThread().getName();//Obtenemos el nombre del hilo
        for(int i=0; i<this.rounds; i++) {
            try{
                Thread.sleep(200);
                System.out.println("Running round: "+i+" Thread "+ threadName);
                //threadA.join();
            }catch(InterruptedException e) {
                System.out.println(e);
            }
        }
        this.result=1;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        UseJoin threadA = new UseJoin(4);
        UseJoin threadB = new UseJoin(2);
        threadA.start();
        threadB.start();
        try{
            //threadA.join();
            threadB.join();
        }catch(InterruptedException e) {
            System.out.println(e);
        }
        System.out.println("Result: "+ threadA.result + threadB.result);
    }

}