Qu'est-ce qu'un bon programme parallèle [avec Java Thread]?

J'apprends le Thread-ing en Java afin de créer un programme exécuté en parallèle. Concevoir des programmes avec parallélisme est quelque chose que je n'ai jamais eu la chance d'apprendre à mon cours de programmation scolaire. Je sais comment créer des threads et les faire fonctionner, mais je ne sais pas comment les utiliser efficacement. Après tout, je sais que ce n'est pas en utilisant des threads qui rend un programme rapide mais une bonne conception parallèle. J'ai donc fait une expérience pour tester mes connaissances. Cependant, mon parallèle la version fonctionne en fait plus lentement qu'une version inégalée. Je commence à douter si je comprends vraiment l'idée. Si vous pouviez être si gentil, cela vous dérangerait-il de regarder mon programme suivant:

J'ai créé un programme pour remplir un tableau de manière divisée et conquérante (je sais que Java a des tableaux.remplir l'utilitaire, mais je veux juste tester mes connaissances en multithreading):

public class ParalledFill
{
    private static fill(final double [] array, 
                        final double value, 
                        final int start, 
                        final int size)
    {
        if (size > 1000) 
        { // Each thread handles at most 1000 elements
            Runnable task = new Runnable() { // Fork the task
                public void run() { 
                    fill(array, value, start, 1000); // Fill the first 1000 elements
            }};
            // Create the thread
            Thread fork = new Thread(task);
            fork.start(); 
            // Fill the rest of the array
            fill(array, value, start+1000, size-1000);
            // Join the task
            try {
                fork.join();
            }
            catch (InterruptedException except)
            {
                System.err.println(except);
            }
        }
        else 
        { // The array is small enough, fill it via a normal loop
            for (int i = start; i < size; ++i)
            array[i] = value;
        }
    } // fill

    public static void main(String [] args)
    {
        double [] bigArray = new double[1000*1000];
        double value = 3;
        fill(bigArray, value, 0, bigArray.length);
    }
}

J'ai testé ce programme, mais il s'avère encore plus lent que de simplement faire quelque chose comme:

for (int i = 0; i < bigArray.length; ++i)
    bigArray[i] = value;

J'avais ma supposition, il pourrait quoi qu'il en soit, java effectue une optimisation pour remplir un tableau à l'aide d'une boucle, ce qui le rend beaucoup plus rapide que ma version threadée. Mais à part cela, je pense plus fortement que ma façon de gérer les threads/parallélisme pourrait être fausse. Je n'ai jamais rien conçu en utilisant des threads (toujours basé sur l'optimisation du compilateur ou OpenMP en C). Quelqu'un pourrait-il m'aider à expliquer pourquoi ma version parallèle n'est pas plus rapide? Le programme était-il trop mauvais en termes de conception de programme parallèle?

Merci, Xing.