Discussion :

[MaelstroeM]

Bonjour,

Voila je dispose d'une classe d'outils qui n'est qu'une liste de méthode Shared (Static) permettant d'enregistrer des fichiers de logs.

Ces méthodes sont utilisées dans un context multithread pour enregistrer les erreurs de traitements des travaux.
Chaque thread travaillant sur un "travail" different je sais qu'il n'est pas possible que 2 threads utilisent le même fichier car j'utilise un ID unique pour chaque travail que je place dans le nom du fichier de log.

Cependant y a t il un risque ici à utiliser des methodes Shared sans verrou ?
Dans ces methodes, il n'y a aucun appelle à d'autre variable "Shared".

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
Public Overloads Shared Sub LogException(ByVal RaisedException As System.Exception, ByVal ApplicationMessage As String, ByVal ID as String)
 
            Dim AppLogFile As String = My.Application.Info.DirectoryPath.Substring(0, 3)
            AppLogFile &= My.Application.Info.ProductName
            AppLogFile &= IO.Path.DirectorySeparatorChar
 
            If Not My.Computer.FileSystem.DirectoryExists(AppLogFile) Then
                My.Computer.FileSystem.CreateDirectory(AppLogFile)
            End If
            AppLogFile &= ID & "_LogException.txt"
 
            Using swLogWriter As StreamWriter = File.AppendText(AppLogFile)
 
                swLogWriter.WriteLine("-------------------------------Start Log Entry-------------------------------")
                If Not IsNothing(RaisedException) Then
                    LogExceptionOnFile(RaisedException, ApplicationMessage, swLogWriter, False)
                Else
                    LogExceptionOnFile(New System.Exception("No Exception To Log"), ApplicationMessage, swLogWriter, False)
                End If
                swLogWriter.WriteLine("-------------------------------End Log Entry---------------------------------")
                swLogWriter.Close()
            End Using
 
    End Sub

Si potentiellement problème il y a, en n'utilisant plus de methodes partagées et en creant dans chaque thread une instance de la classe de log le problème est il résolu ? On même envisage de ne créer cette instance que dans le Catch pour ne pas instancier un nouvel objet si le traitement ce passe bien.

Merci de vos conseils !!

[SaumonAgile]

Pourquoi recoder une classe de log, alors qu'il y a déjà tout ce qu'il faut directement dans le framework avec l'objet Trace par exemple ?
Tu te retrouves avec des problématiques inutiles...

[MaelstroeM]

Oui c'est juste mais le problème pourrait se poser avec avec autre chose qu'un fichier de log. l'histoire du fichier c'est presque qu'une illustation de la problèmatique... ça pourrait être un envoi de mail par exemple.

Je cherche surtout à évaluer le risque potentiel que représente l'utilisation de méthodes partagées dans un context multithread. Et je ne trouve pas bcp de doc sur le sujet.

Par exemple si deux thread execute un Dim MonIntance as new MaClasse qui se trouve dans une méthode Shared que se passe t vraiment ? Les deux on leur propre instance, où le dernier va "suicider" l'autre...

Bref je me pose des questions de ce genre...

[pacmann]

Salut,
Je pense que même si tes méthodes sont shared, l'exécution en soi du code ne devrait pas poser de problème.
A priori, même si c'est le même code qui est exécuté, les pointeurs d'exécutions sont bien distincts, et les variables locales également.
Comme tu le dis, il pourrait y avoir un problème sur les ressources partagées comme les propriétés shared... (par exemple si l'ID était shared et incrémenté par une méthode d'allocation...)

[The eye]

Si ta méthode est une méthode shared qui ne met à jour aucune variable shared alors tu n'auras aucun problèmes de conflits.

Attention cependant, tu peux avoir des conflits propres à ton code, si tu doit écrire dans un fichier par exemple... si tes threads essayent d'y accéder en même temps cela peut poser des problèmes d'accès.

Mais si tu dois, par exemple, récupérer des données en BDD à partir d'une méthode shared, alors tu peux l'appeler avec plusieurs threads sans qu'il n'y ait de conflit.