Discussion :

[Satch]

Bonjour, quelque chose a du m'échapper dans le fonctionnement des threads. J'ai fait le code suivant :

En résumé, il instancie 4 Threads, les lance tous les 4 et les threads inscrivent leur nom en boucle sur la console.
L'un d'eux a une haute priorité, et l'autre une basse.

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
    class Program
    {
        static void Main(string[] args)
        {
            Thread[] threads = new Thread[4];
 
            for (int i = 0; i < 4; i++)
            {
                Feux feu = new Feux();
 
                ThreadStart entryPoint = new ThreadStart(feu.run);
                threads[i] = new Thread(entryPoint);
                threads[i].Name = "thread " + i;
                threads[i].Start();   
            }
            threads[0].Priority = ThreadPriority.Lowest;
            threads[2].Priority = ThreadPriority.Highest;
 
        }
    }
 
    class Feux
    {
        static Object Mutex = new Object();
        EtatFeux etatFeux;
 
        public void run()
        {
            while (true)
            {
                lock (Mutex)
                {
                    Console.WriteLine(Thread.CurrentThread.Name);
                    Thread.Sleep(50);
 
                }
            }
        }
 
    }

Je m'attendais à avoir en sortie les noms des threads dans n'importe quel ordre, avec plus de "thread 2" et moins de "thread 0".

Seulement j'obtiens invariablement la même sortie.

Qu'est-ce que j'ai mal compris ? Là je ne vois pas.

Merci d'avance.

[NicolasG]

Le fonctionnement que tu observes est dû à l'utilisation de lock.
lock() autorise un seul thread à accéder au code Console.WriteLine().
Chacun des autre threads est bloqué et attend la libération de la portion de code en question par le thread précédent.
On peut considérer que lock maintient une FIFO des threads en attente.

La priorité n'a pas d'influence puisque le thread de haute priorité passe son temps à attendre que les threads de basse priorité sortent de la portée de lock()