Hacer Tareas Con hilos rapido o lento?

[deitynitros98]

Buenas, la pregunta es muy simple, tengo 2 tareas en mi código, cuando ejecuto estas tareas una detrás de la otra en lugar de hacerlas cada una con un hilo, el procesador tiene mejor rendimiento... Esto no es lo que yo esperaba, esperaba que realizando ambos procedimientos con hilos, resultaría mas eficiente y rapido, pero según el calculo de tiempo la ejecución es mucho mejor cuando se hace secuencialmete. Esto es normal??, ya que, en la clase de programación concurrente el profesor dice que dividir un problema entre varios hilos, resulta mucho mas rápido que ejecutarlo de forma normal y secuencia....

[LuisChavezB]

Depende mucho del numero y tipo de tareas. No solo es poner todo el código en un hilo y correrlo, tienes que identificar que parte de tu código es mejor correrlo en varios hilos.

[deitynitros98]

Bueno Simplemente son 2 tareas que no tienen que ver ninguna con la otra

Código:

package multi_matrices_hilos;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Multi_MAtrices_Hilos {    
    
    public static void main(String[] args) {
        GestorTareas gt = new GestorTareas();
        try{
            gt.Ciclo_Principal();
            
        }catch(Exception E){}
    }    
}

class GestorTareas {
    private Menu menu;
    private Multiplicar_Matriz datos;
        
    public GestorTareas(){
        menu = new Menu();
        datos  = new Multiplicar_Matriz(4000,4000,4000);
        menu = new Menu();
        
    }
    
    public void Ciclo_Principal() throws InterruptedException  
    {
        
        new Thread(datos).start();
        Thread.sleep(1);
        datos.set_numSubProceso((byte)1);        
        new Thread(datos).start();
        //datos.set_numSubProceso((byte)3);
        
        //datos.GenerarMatrizA();
        //datos.GenerarMatrizB();
        
        int op;
        try{
            op = menu.menu();
            gestor_opciones(op);
        
        }catch(Exception e){
            System.out.print("Error" + e.getMessage());
           // throw e;
        }
    }
    private void gestor_opciones(int op) throws IOException
    {
        switch(op)
        {
            case 1:
                menu.datos_M_N_S();                
                break;
            case 4:
                break;
        }
    }    
}

class Menu 
{
    private BufferedReader br;
    
    public Menu()
    {
        br = new BufferedReader( new InputStreamReader(System.in));
    }
    public int menu() throws IOException
    {
        System.out.println("1.Cargar Nuevos Matrices Datos.");
        System.out.println("2.Mostrar Matriz A.");
        System.out.println("3.Mostrar Matriz B.");
        System.out.println("4.Iniciar.");
        System.out.println("5.Salir.");
        
        return Integer.parseInt(br.readLine());
    }
    public int[] datos_M_N_S() throws IOException
    {
        int[] MNS = new int[3];
        System.out.print("\nInsertar M: ");
        Integer.parseInt(br.readLine());        
        System.out.print("\nInsertar N: ");
        Integer.parseInt(br.readLine());
        System.out.println("\nInsertar S: ");
        Integer.parseInt(br.readLine());
        
        return MNS;
    }
}


class Multiplicar_Matriz implements Runnable
{
    
    @Override
    public void run() {
        switch(numSubProceso)
        {
            case 0:   
                GenerarMatrizA();
                break;
            case 1:   
                GenerarMatrizB();
                break;
            case 2:   
                break;
        }        

    }
    public Multiplicar_Matriz()
    {
       numSubProceso = 0;
    }
    public Multiplicar_Matriz(int M,int N,int S)
    {
        this();
        this.M = M;this.N = N;this.S = S;
        MatrizA  = new int[M][N];
        MatrizB  = new int[N][S];
        Matriz_C = new int[M][S];        
    }
    
    public void GenerarMatrizA()
    {
        long tiempoInicio = System.currentTimeMillis();
        for(int i=0;i<M;i++)for(int j=0;j<N;j++) 
            MatrizA[i][j] = (int) Math.floor(Math.random()*(101));
        
        long totalTiempo = System.currentTimeMillis() - tiempoInicio;
        
        System.out.println("El Tiempo en generar la MatrizA es: "+totalTiempo);
    }
    
    public void GenerarMatrizB()
    {
        long tiempoInicio = System.currentTimeMillis();
        for(int i=0;i<N;i++)for(int j=0;j<S;j++) 
            MatrizB[i][j] = (int) Math.floor(Math.random()*(101));
        
        long totalTiempo = System.currentTimeMillis() - tiempoInicio;
        
        System.out.println("El Tiempo en generar la MatrizB es: "+totalTiempo);
    }
    
    public void multiplicarMatrices_A_B()
    {
        for (int k = 0; k < M; k++)for( int j = 0; j < S; j++)for(int i = 0; i < N; i++ )             
           Matriz_C[k][j] += MatrizA[k][i] * MatrizB[i][j];
    }
    
    public void mostrarMatricesC()
    {
        for(int i = 0; i < M; i++ ){for(int j = 0; j < S; j++)System.out.print(Matriz_C[i][j]+" ");
           System.out.println();
        }
    }
    
    public void set_numSubProceso(byte numSubProceso)
    {
        this.numSubProceso = numSubProceso;
    }
    
    private int M,N,S;
    private static int[][] Matriz_C;
    private int[][] MatrizA;
    private int[][] MatrizB;
    private byte numSubProceso;    
}

esta muy facil de entender

[chuidiang]

Hola:

Depende del microprocesador.

Con un solo micro, dos hilos es más lento que dos tareas secuenciales. Los hilos requieren un "cambio de contexto" en el micro que las tareas secuenciales no.

Si el micro es en realidad un micro multi procesador, y el sistema operativo y java hacen uso de ello, es posible que los dos hilos se ejecuten cada uno en uno de los procesadores, siendo entonces más rápido que hacerlo secuencialmente.

Los hilos en general se usan para hacer más rápido el código en sistemas multiprocesador, o bien para que al usuario le parezca que se están haciendo varias cosas a la vez.

Se bueno.