Dúvida com tempo de execução de threads

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.

Para esperar uma thread terminar, use o método “join”.

Se você sabe ler diagramas de atividade UML, o “join” é o equivalente do elemento “join” desse tipo de diagramas. Veja um exemplo em:

Atenção: usar isAlive() em 99,9% dos casos é desaconselhado porque implica em “polling” e isso é uma operação custosa.
Usa-se quase sempre “join”.
Usar “isAlive” é só adequado para fazer monitoração de threads, mas não atividades de controle, como é o que você quer fazer.

entanglement, obrigado pela ajuda.

Foi justamente a luz que eu precisava. Utilizando o join consegui fazer funcionar sem nenhum problema.

Pesquisando sobre Join() li o artigo abaixo, que foi de bastante ajuda…

http://www.guj.com.br/java/70198-duvida-metodo-join-em-thread–respondido—pelo-menos-eu-entendi-

Eis o código final…

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
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 valor1, double valor2)
    {
        System.out.println("Média: "+ ((valor1 + valor2) / 2));
    }
 
    public static void main(String[] args) {
        // TODO code application logic here
       
        //Criando threads com runnable
        Thread1 thread = new Thread1();
        Thread utilizandoRunnable = new Thread(thread);
        Thread2 thread2 = new Thread2();
        Thread utilizandoRunnable2 = new Thread(thread2);
       
        // Inicializando threads
        utilizandoRunnable.start();
        utilizandoRunnable2.start();
           
       try
       {
        utilizandoRunnable.join();
        utilizandoRunnable2.join();
        calcularMediaFinal(thread.getMedia1(), thread2.getMedia2());
       }
       catch(InterruptedException erro)
       {
           System.out.println("Erro: "+ erro);
       }
    }
}