Bonjour,
j'ai expérimenté les threads en C# et je n'arrive pas à interpréteur certains résultats et d'autre je n'en suis pas sur. J'ai donc une classe ThreadTester avec un attribut _numIteration qui sera décrémenté dans la méthode Treatment à chaque passage.

1) Constatation A : J'ai remarqué que le temps pour éxecuter X tours de boucles n'était pas divisé par le nombre de thread mais avait même tendance à être encore plus élevé ( 38 sec pour 2 threads, 19 sec pour 1 thread par exemple).
Constatation B : Les deux CPU du core 2 duo sont à 100% d'utilisation.
Explication : Je pense que c'est tout simplement parce que les threads ne s'exécute pas en parallèle mais un à la fois sur le même CPU.
Mais alors pourquoi, si les 2 CPU sont à 100% le temps n'est pas divisé en deux mais plutot multiplié?? Un changement de contexte ferait perdre autant de temps ?

2) Constatation : La somme des décrémentations est quasi toujours supérieur à _numIteration initial si au moins 2 threads ont eu le temps de décrémenter.
Explication : Je n'en sais rien du tout.

3) Question : Quelle est la meilleur solution pour multiplier le gain de temps par le nombres de Threads ?

Au passage, n'hésitez pas à faire d'autres critiques sur le code qui n'ont rien avoir avec le sujet.


Merci d'avance


Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
class ThreadTester
    {
        long _numIteration = 0;
        DateTime _tic ; //start time
 
        public ThreadTester(long numIteration)
        {
            _numIteration = numIteration;
        }
 
        /*
         * Lance autant de thread que l'argument en paramètre.
         */
        public void LaunchThread(int numThread)
        {   
            Thread thread = null;
            _tic = DateTime.Now;
 
            while (numThread > 0)
            {
                thread = new Thread(Treatment);
                thread.Priority = ThreadPriority.Lowest ; // Pour que le thread traité par le processeur change le plus souvent possible.
                thread.Start();
 
                numThread--;
            }
        }
 
        /*
         * Methode qui sera lancé dans un thread et qui se charge de décrémenter _numIteration.
         */
        private void Treatment()
        {
            long done = 0; //Permet de compter le nombre de décrémentation.
            while ( _numIteration > 0 )
            {
                // Je pense que c'est nécéssaire de mettre ici une zone critique mais je n'en suis pas sur à 100%
                Thread.BeginCriticalRegion();
                done++;
                _numIteration--;
                Thread.EndCriticalRegion();
            }
 
            Print(done);
        }
 
        /*
         * Imprime le délai de temps depuis le lancement de LaunchThread et le nombre de décrémentation.
         */
        private void Print(long done)
        {
            DateTime delay = new DateTime(DateTime.Now.Ticks - _tic.Ticks);
            Console.WriteLine(String.Format("{4}> {0}:{1}:{2} || done : {3}", delay.Minute, delay.Second, delay.Millisecond, done, Thread.CurrentThread.GetHashCode()));
        }
    }