Galera, estou começando a estudar threads na faculdade e tenho uma dúvida.
Pelo que li, a thread main, não espera outras threads finalizarem para continuar sua execução e meu problema é justamente como fazer ela espera.
Explicando melhor meu problema:
Tenho um vetor de 10 posições, onde devo por meio de duas threads calcular a média dos valores de metade do vetor. Essa parte consegui fazer. Agora quando pego os valores de média de cada thread para fazer a média final, em cada execução tenho um resultado diferente pois a média final está sendo calculada antes de as threads terminarem sua execução.
Eis o código que consegui fazewr até agora:
package atividade1;
 
/**
 *
 * @author Anderson
 */
public class Atividade1 {
 
    /**
     * Escreva um programa em java que faça uso de duas threads para somar os
     * elementos de um vetor de inteiros de tamanho 10 e calcular a média de
     * maneira colaborativa. Cada thread deve gerar a média de metade dos
     * elementos.
     */
   
    static int vetor[] = {9, 6, 3, 5, 1, 7, 8, 2, 1, 7};
   
    static class Thread1 implements Runnable{
        private double media;
        @Override
        public void run()
        {
           
            double soma = 0;
            int cont = 0;
            for(int i=0; i<5; i++)
            {
                soma = soma + vetor[i];
                cont++;
            }
             media = soma / cont;
            System.out.println(media);
        }
       
        public double getMedia1()
        {
            return this.media;
        }
    }
       
        static class Thread2 implements Runnable{
            private double media;
            @Override
            public void run()
            {
               
                double soma = 0;
               
                int cont = 0;
                for(int i=5; i<10; i++)
                {
                    soma = soma + vetor[i];
                    cont++;
                }
                media = soma / cont;
                System.out.println(media);
            }
                public double getMedia2()
                {
                    return this.media;
                }
        }
       
        static public void calcularMediaFinal(double media1, double media2)
        {
            System.out.println("Média: "+ ((media1 + media2) / 2));
        }
       
       
    public static void main(String[] args) {
        // TODO code application logic here
       
        Thread1 thread = new Thread1();
        Thread utilizandoRunnable = new Thread(thread);
        Thread2 thread2 = new Thread2();
        Thread utilizandoRunnable2 = new Thread(thread2);
        utilizandoRunnable.start();
        utilizandoRunnable2.start();
        calcularMediaFinal(thread.getMedia1(), thread2.getMedia2());
        
 
    }
}O programa em si, é só um exercício, mas não espero que ninguém me entregue-o pronto, mas sim que me ajude a enxergar onde estou errando.
Como estou começando, acredito que a forma que estou utilizando as threads não seja a mais adequada, mas foi só assim que consegui fazer…
Já tentei utilizar if (!utilizandoRunnable.isAlive()); para verificar o termino da thread antes de processar a média final, mas não funcionou e li também sobre locks (synchronized), mas não entendi muito bem como este último funciona.
Desde já, agradeço qualquer luz que me derem.