Discussion :

[BasicZX81]

Bonsoir a tous,
Je commence a peine a me lancer dans le multithread et je rencontre un problème d’accès a une méthode a partir de plusieurs Threads, je m'explique :
Actuellement j'utilise une méthode pour Désactiver des événements le temps de faire de gros traitements sur des DataTable, puis pour réactiver ces événements dés que les traitements sont terminés. cette méthode est appelée ponctuellement a divers endroit de mon code mais toujours depuis le Thread principale (Thread A) ce qui ne pose aucun problème.

Aujourd'hui j'ai besoin de faire la même action mais depuis un Thread secondaire (Thread B) seulement les Threads risquent de se faire concurrences aux niveaux des Activation/Désactivation. Il faudrait que si Thread A désactive les Events, alors Thread B n'a pas le droit les réactiver tant que Thread A n'a pas terminé et réactivé ces Events, (il doit attendre sont tour). Idem depuis Thread B. (Le fonctionnement normal de l'application veux que ces événements soit toujours activés en temps normal). Je ne sais pas du tout comment faire cela.

Cela donne un truc du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
ActiveControlesHandler(False)
' ici on lance des opérations sur un DataTable
ActiveControlesHandler(True)

Le code pour Désactiver/Activer les évenements :

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
Dim ControleHanddlerIsActive As Boolean
Public Sub ActiveControlesHandler(ByVal State As Boolean)
 
        If State = True And ControleHanddlerIsActive = False Then
            AddHandler DataGridView1.CurrentCellDirtyStateChanged, AddressOf EventCurrentCellDirtyChanged
            AddHandler MainBindingSourcePaths.CurrentItemChanged, AddressOf EventbsCurrentItemChanged
            AddHandler MainBindingSourcePaths.CurrentChanged, AddressOf EventbsCurrentChanged
            AddHandler MainBindingSourcePaths.PositionChanged, AddressOf EventbsPositionChanged
            AddHandler dtTablePaths.ColumnChanging, AddressOf EventTableColumnChanging
            AddHandler dtTablePaths.ColumnChanged, AddressOf EventTableColumnChanged
            AddHandler dtTablePaths.TableNewRow, AddressOf EventTableNewRow
 
            ControleHanddlerIsActive = True
        ElseIf State = False And ControleHanddlerIsActive = True Then
            RemoveHandler DataGridView1.CurrentCellDirtyStateChanged, AddressOf EventCurrentCellDirtyChanged
            RemoveHandler MainBindingSourcePaths.CurrentItemChanged, AddressOf EventbsCurrentItemChanged
            RemoveHandler MainBindingSourcePaths.CurrentChanged, AddressOf EventbsCurrentChanged
            RemoveHandler MainBindingSourcePaths.PositionChanged, AddressOf EventbsPositionChanged
            RemoveHandler dtTablePaths.ColumnChanging, AddressOf EventTableColumnChanging
            RemoveHandler dtTablePaths.ColumnChanged, AddressOf EventTableColumnChanged
            RemoveHandler dtTablePaths.TableNewRow, AddressOf EventTableNewRow
 
             ControleHanddlerIsActive = False
        End If
    End Sub

Je vous remercie beaucoup pour votre aide.

[Pol63]

à côté de la méthode ActiveControlesHandler tu met une variable privée as integer

quand tu rentres dans la méthode avec false tu fais +1 dessus, si l'int = 1 tu désactive
quand tu rentres avec true, tu fais -1, si l'int = 0 tu actives
ainsi lors du 2ème appel avec false l'int vaudra 2 et exit sub car ne vaut pas 1 (et ca aura été désactivé à 1)
lors du 1er true tu passes de 2 à 1 et exit sub car pas 0
lors du 2eme true tu passes à 0 et ca réactive

par contre il faut un synclock, ou alors l'incrémentation atomique mais je ne sais plus où elle est car en multithreading si 2 threads passent en même temps sur la ligne varint += 1 il se peut qu'en partant de 1 on arrive à 2 au lieu de 3
chaque thread va lire la valeur (1) puis faire +1 (2) puis ranger dans la variable
il faut donc interdire à 2 threads de faire ca en même temps

[BasicZX81]

Bonsoir et merci de m'avoir répondu.
J'ai dus relire plusieurs fois car au début j'ai cru que cela ne réglait le problème qu'a moitié, en effet avec cette technique on ne mets pas en attente le Thread B si le Thread A a débuter une opération. En y réfléchissant bien c'est vraiment très astucieux car en effet il est inutile de vouloir rentrer dans la procédure (et mettre un Thread en attente) afin de la désactiver si celle-ci l'a déjà été par un autre Thread. Et la réactivation ne s'effectue que si il n'y a plus aucun Thread qui nécessite une désactivation.

Franchement vous êtes quelqu'un sur le site a données des réponses pertinentes a chaque fois, ça me laisse admiratif.
Je ne marque pas résolue tout de suite car je dois procéder a des essais, je le ferais plus tard. Et encore merci

[Pol63]

je veux bien croire qu'il faille relire plusieurs fois, c'est juste prémaché, il faut modéliser le tout pour comprendre le fonctionnement

sinon il faut bien cerner la problématique, si le but est de laisser en attente un thread il y a synclock qui permet de faire ca, ou éventuellement le readerwriterlockslim qui permet de gérer des cas de manière plus optimisé que synclock

si votre thread répond à une demande de chargement et que votre 2ème thread doit remplacer le traitement du 1er il y a mieux que de verrouiller l'accès, il faut annuler le 1er avec là aussi plusieurs méthodes

la technique que je vous ai donné c'est pour permettre de suspendre quelque chose dans le cas de x entrées de la méthode jusqu'à la xième sortie en gros
si vos 2 threads ont réellement besoin de faire le travail en même temps ca devrait convenir
on trouve ce genre de comportement dans le framework, comme dans la méthode suspendlayout/resumelayout, on peut appeler suspend plusieurs fois, et il faut appeler resume autant de fois pour réactiver le calcul du layout
décompiler le framework quand on veut comprendre comment marche l'outil qu'on utilise est une des méthodes qui permet d'apprendre plein de techniques
poser des questions pertinentes ici a l'air d'en être une autre ^^
il y a aussi des tutos sur les design pattern les plus courants, qui sont des méthodes connues qui répondent à des problématiques, de conception ou de performance (singleton, factory, lazy initialization etc...)


pour l'incrément atomique c'est interlocked.increment/decrement(variable)

[BasicZX81]

Merci beaucoup pour l'explication.
En fait je ne sais pas très bien ce qu'il faut verrouiller, c'est là tout le problème. La seule chose dont je suis sûre c'est que je dois désactiver ces événements lors de certaines opérations et je ne maîtrise pas vraiment le moment quand ces opérations se produisent et donc il y a une probabilité pour que les Threads travaillent en même temps.
Voilà ou j'en suis pour l'instant :

J'ai ajouté une région critique afin de garantir la réactivation des événements en cas d’interruption du Thread.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Thread.BeginCriticalRegion()
ActiveControlesHandler(False)
' ici on lance des opérations sur un DataTable
ActiveControlesHandler(True)
Thread.EndCriticalRegion()

A la place de 0 et 1, je fait un test avec -1 et 0, cela m’évite d'initialiser la variable lors de la première activation.

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
Dim ControleHanddlerIsActive As Boolean
Dim ControleHandlerCounterOfDésactive As Integer
Public Sub ActiveControlesHandler(ByVal State As Boolean)
 
        If State = False Then
            Interlocked.Increment(ControleHandlerCounterOfDésactive)
        Else
            Interlocked.Decrement(ControleHandlerCounterOfDésactive)
        End If
 
        If State = True And ControleHanddlerIsActive = False And ControleHandlerCounterOfDésactive = -1 Then
            AddHandler DataGridView1.CurrentCellDirtyStateChanged, AddressOf EventCurrentCellDirtyChanged
            AddHandler MainBindingSourcePaths.CurrentItemChanged, AddressOf EventbsCurrentItemChanged
            AddHandler MainBindingSourcePaths.CurrentChanged, AddressOf EventbsCurrentChanged
            AddHandler MainBindingSourcePaths.PositionChanged, AddressOf EventbsPositionChanged
            AddHandler dtTablePaths.ColumnChanging, AddressOf EventTableColumnChanging
            AddHandler dtTablePaths.ColumnChanged, AddressOf EventTableColumnChanged
            AddHandler dtTablePaths.TableNewRow, AddressOf EventTableNewRow
            Debug.Print(String.Format("Les évenements ont été activés par le tread [{0}] <{1}>", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.Name))
 
            ControleHanddlerIsActive = True
        ElseIf State = False And ControleHanddlerIsActive = True And ControleHandlerCounterOfDésactive = 0 Then
            RemoveHandler DataGridView1.CurrentCellDirtyStateChanged, AddressOf EventCurrentCellDirtyChanged
            RemoveHandler MainBindingSourcePaths.CurrentItemChanged, AddressOf EventbsCurrentItemChanged
            RemoveHandler MainBindingSourcePaths.CurrentChanged, AddressOf EventbsCurrentChanged
            RemoveHandler MainBindingSourcePaths.PositionChanged, AddressOf EventbsPositionChanged
            RemoveHandler dtTablePaths.ColumnChanging, AddressOf EventTableColumnChanging
            RemoveHandler dtTablePaths.ColumnChanged, AddressOf EventTableColumnChanged
            RemoveHandler dtTablePaths.TableNewRow, AddressOf EventTableNewRow
             Debug.Print(String.Format("Les évenements ont été désactivés par le tread [{0}] <{1}>", Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.Name))
 
             ControleHanddlerIsActive = False
        End If
    End Sub

Pour l'instant je pense que l'on est sur la bonne voie mais quelque chose me dit que je devrais peut être rajouter un Synclock/End SyncLock et je ne sais pas comment exactement ni si cela est vraiment nécessaire. En effet je n'ai pas nécessairement besoin de mettre un Thread en attente a condition que ma procédure soit suffisamment vérouillées (c'est ma crainte), c'est a dire que dans le cas ou 2 threads rentre en même temps dans la procédure il ne faudrait pas que l'un active pendant que l'autre désactive ou encore que cela entraîne une erreur dans le décompte de la variable integer car ensuite je ne pourrais plus réactiver. Je ne sais pas trop répondre a cette question.
Bien sûr dans mon programme pour chaque désactivation correspond une réactivation, les appels sont équilibrés.

Merci beaucoup si vous pouvez m'aider.

[Pol63]

je ne connaissais pas Thread.BeginCriticalRegion, je vais regarder ce que ca donne
mais si j'ai bien compris ca sert à arrêter l'appli suite à un abort, et je ne suis pas sur que vous ayez compris la même chose ...