Notion sur les Threads en Java.

Question

Bonjour,

Chers tous, quelqu'un pourrait m'aider avec des explications sur la  notion de Threads en programmation Java.? A quoi nous servent ces Threads ? Un exemple réel sur ça ( du code please) Merci beaucoup.

Whismeril · Answer

Bonjour

Les thread n'ont rien à voir avec java.

Donc les explications non plus.

Un thread c'est un fil d'exécution. Un programme a au moins un thread, dans lequel les instructions du programme sont exécutées dans l'ordre. C'est ce qu'on appelle un fil d'exécution.

En programmation multi threads, plusieurs fils sont exécutés en même temps.

Cas de la barre de progression: ton programme mono thread fait une action longue (télécharger un gros fichier par exemple), tu veux afficher une barre de progression, mais à l'exécution ton programme reste figé et au bout d'un moment la barre apparaît remplie. C'est parce qu'il n'y a qu'un thread et que tant que le calcul long n'est pas fini, il ne peut rien se passer d'autre. En plaçant ce calcul dans un second thread qui remonte régulièrement une progression vers le thread principal, le thread principal peut mettre à jour la barre de progression et la fenêtre ne fige pas.
	Cas de calcul parallelisé: tu dois calculer la moyenne d'un million de valeurs. Tu as essayé avec 10 000, ça prend moins d'une seconde. Avec 100 000, ça prend 15 secondes, et avec un million presqu'une minute. Une solution est de découper la liste de valeurs en 10 sous listes, et de faire calculer la moyenne de chaque sous liste à un thread différent et ensuite de faire la moyenne des 10 résultats intermédiaires. Et là, ça prend 5 secondes.

Les points à prendre en compte sont

faire attention si plusieurs threads utilisent les mêmes données, modifier une variable dans l'un peut avoir des conséquences dans un autre. Souvent on utilise des sémaphores qui bloquent l'accès à cette variable pour les autres threads. Mais du coup, on stoppe ces threads et on perd le bénéfice de la parallélisation. Il faut limiter le partage de variables le plus possible. Dans le cas de la moyenne, chaque thread qui calcule utilise sa liste et pas la liste principale de l'index i à l'index j.
	faire attention quand on parrallélise, d'attendre que tous les threads aient fini leur tache avant de passer à la suite. On peut utiliser un thread qui repartit le travail aux autres et les attends avant de renvoyer le résultat au thread appelant.
	être rigoureux dans sa conception, à un moment ça peut être "inception" (si tu n'as pas vu ce film je te le conseille)

KX · Answer

Bonjour,

Je plussoie les explications de Whismeril.

Toutefois attention au tutoriel qui date de juillet 2004 (Java 4), le langage a beaucoup évolué en 20 ans (actuellement nous sommes en Java 21), en particulier pour améliorer les performances et donc l'usage des threads.

Un petit code qui reprends l'exemple du calcul de moyenne de valeurs :

import java.util.stream.IntStream;

public class Test {
    public static void main(String...args) {
        average(1_000);
        average(1_000_000);
        average(1_000_000_000);
    }

public static void average(int n) {
        System.out.println("n=" + n);
        var t0 = System.currentTimeMillis();
        var avg1 = IntStream.range(1, n).average().getAsDouble();
        var t1 = System.currentTimeMillis();
        var avg2 = IntStream.range(1, n).parallel().average().getAsDouble();
        var t2 = System.currentTimeMillis();

System.out.println("avg1="+avg1+"; t="+(t1-t0));
        System.out.println("avg2="+avg2+"; t="+(t2-t1));
    }
}

Le résultat dépend beaucoup des performances de la machine, voici les miens
NB. les temps sont en millisecondes

n=1000
avg1=500.0; t=1
avg2=500.0; t=2

n=1000000
avg1=500000.0; t=5
avg2=500000.0; t=16

n=1000000000
avg1=5.0E8; t=305
avg2=5.0E8; t=35

Une explication s'impose :

Pour un tout petit nombre de valeurs (1000), les temps sont quasiment identiques (à 1ms près), pour 1 million de valeurs le temps de calcul de avg1 est plus rapide que avg2 (à 10ms près) alors que pour 1 milliards de valeurs, le temps de calcul de avg1 est 10 fois plus lent que avg2.

Cela s'explique par le coût de mise en place du parallélisme, qui n'est pas neutre. Ainsi pour 1000 valeurs comme pou 1 million, le temps de calcul dédié à la mise en place du parallélisme est supérieur au gain que cela nous apporte. Toutefois plus le nombre de valeurs augmente, plus ce surcoût va être compensé par le gain du parallélisme, on le voit bien avec 1 milliard.

Notion sur les Threads en Java.

2 réponses

Votre réponse

Discussions similaires