[C#] MultiThread Cross

Version imprimable

Bonjour,
J'ai une application possédant une classe gérant l'accès aux bases de données via les méthodes open(), close(), read() et write() (il y en a d'autres, mais bon.
Je voudrais être sûr que mes threads ne puissent accéder aux bases de données que un par un, pour ce faire, je pensais donc utiliser un Mutex dans ma classe d'accès aux bases; la classe Acces.

Ca me donne un truc comme ça :

Code:

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
57
58
 
static System.Threading.Mutex myMut ;
 static public System.Threading.Mutex MyMut {
get{ 
if(myMut == null ) myMut=new System.Threading.Mutex(); return myMut; } }
 
public bool open()
        {
            bool bRet = false;
            int iOpenCount = 0;
            try
            {               
                try
                {
                    lock (MyMut)
                    {
                        MyMut.WaitOne();
                    }
                }
                catch(System.Threading.AbandonedMutexException ex)
                {
                    string s = ex.ToString();
                }
                if (odbcConn.State == ConnectionState.Closed)
                {
                    odbcConn.Open();
                    CountOpen++;
                }
 
                bRet = true;
            }
            catch (Exception exx)
            {
                close();
                LastError = exx.Message;
                bRet = false;
                Alerte.LancerAlerte(Planning.Variables.myLog, "Base de données :\r\n" + dbName + "\r\n\r\nErreur :\r\n" + exx.Message);
            }
            return bRet;
        }
 
public void close()
        {
            CountOpen--;
            if (odbcReader != null)
                odbcReader.Close();
 
            if (odbcConn.State == ConnectionState.Open)
                odbcConn.Close();            
            try
            {
                lock (MyMut)
                {
                    MyMut.ReleaseMutex();
                }
            }
            catch (System.Threading.AbandonedMutexException ex) { }
        }

Les autres fonctions de ma classe ne touchent pas au mutex.
J'utilise la classe d'accès de nombreuses fois dans mon programme, et elle est donc instanciée de nombreuses fois, mais ça ne change rien du côté de mon Mutex, ce dernier étant static.
Or, quand je lance mon programme, si il accepte de compiler, il me claque dans les pattes dès qu'il y a du multithread, alors que mon mutex est censé gérer ça !!!

Je débute dans le cross multithread, j'ai bien lu la faq et msdn (je n'ai d'ailleurs pas tout compris mais bon) mais je ne comprends pas pourquoi cela ne marche pas,...
Si quelqu'un pouvait me donner des indications, ça m'aiderait beaucoup !

25/03/2009, 22h20
deejay2221
As-tu essayé d'utiliser seulement la mot clé lock?
Par exemple :
Code:

1 2 3 4 5 6 object barrure; lock (barrure) { // section sensible }
26/03/2009, 08h06
Hurin

Et bien, je peux me tromper, mais il me semble que le mot clé lock servait à empêché que, pour une partie du code donné, un objet ne puisse être utilisé par plusieurs threads différents,...

Or, dans le cas qui m'intéresse, ce n'est pas ce que je veux, je désire juste sécuriser l'accès aux données afin qu'un seul thread à la fois puisse y accéder, mais dans mon code, la classe "gestion acces base de donnée" (que j'ai nommé DBManager) est instanciée plusieurs fois, et dans plusieurs threads différents, et je souhaite donc qu'a chaque tentative d'ouverture, on vérifie que mon mutex est vide, si c'est le cas, on fait le open(), puis, on libère le Mutex avec le Close() de ma classe DBManager, sinon, on attend qu'il se libère,...

J'espère que c'est assez clair, sinon, je peux toujours réexpliquer, merci.
26/03/2009, 09h21
zoubidaman

Non, c'est clair, et oui, utiliser le lock permet de faire ce que tu veux.

Si un thread T1 accède en premier à la db, il lock un objet. Un thread T2 arrive derrière, subit le lock de T1, donc doit attendre que T1 ait délocké l'objet, avant de lui-même le locker pour empêcher un autre thread d'accéder à la DB.
26/03/2009, 09h42
Gold Bug

Citation:

Je voudrais être sûr que mes threads ne puissent accéder aux bases de données que un par un, pour ce faire, je pensais donc utiliser un Mutex dans ma classe d'accès aux bases; la classe Acces.

Je ne comprends pas pourquoi tu essaies d'implémenter ça toi-même. Ces mécaniques sont gérées en natif par tous les moteurs de base de données.

Citation:

Envoyé par Hurin

J'utilise la classe d'accès de nombreuses fois dans mon programme, et elle est donc instanciée de nombreuses fois, mais ça ne change rien du côté de mon Mutex, ce dernier étant static.!

Une bonne solution est d'utiliser le pattern Singleton pour designer ta classe d'accès aux données.
26/03/2009, 12h00
Hurin

Ok, merci pour vos réponses, j'ai utilisé le lock, même si je n'aime pas trop, n'étant pas très habitué,...

Je vais regardé pourquoi ça bug quand je ne le mets pas, car effectivement, comme le dit Gold Bug, je n'ai pas à le faire normalement, c'est donc que le problème doit-être autre part, et pourtant maintenant ça a l'air de marcher, 8O

Je repost dès que j'ai du nouveau, encore merci !
26/03/2009, 12h37
tomlev
Citation:

Envoyé par Hurin

Et bien, je peux me tromper, mais il me semble que le mot clé lock servait à empêché que, pour une partie du code donné, un objet ne puisse être utilisé par plusieurs threads différents,...

Non, ça sert à empêcher que 2 threads exécutent en même temps le même bloc de code.

Fais comme indiqué par deejay2221, mais en déclarant l'objet sur lequel tu lock en statique (commun à toutes les instances), sinon ça ne marche pas...

Citation:

Envoyé par Hurin

Ok, merci pour vos réponses, j'ai utilisé le lock, même si je n'aime pas trop, n'étant pas très habitué,...

Ben ça me parait quand même beaucoup plus simple que d'utiliser un mutex... de toutes façons, un mutex est un mécanisme d'IPC (communication interprocessus), utiliser ça pour gérer la synchro entre les threads d'un même process, c'est un peu comme prendre un bulldozer pour écraser une mouche :aie:

Si je ne dis pas de bêtise, en interne, le compilateur transforme un bloc lock comme celui ci :
Code:

1 2 3 4 lock(toto) { // instructions }
en quelque chose comme ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 try { Monitor.Enter(toto); // instructions } finally { Monitor.Exit(toto); }
26/03/2009, 16h53
Hurin

Ok, merci tomlev ! (l'image du bulldozer et de la mouche était très parlante :lol: )

Donc, je vais utiliser un object static qui me servira à locker dessus pour m'assurer que mon open et mon close ne seront pas "toucher" par 2 threads en même temps !

Merci, je comprends mieux maintenant !
26/03/2009, 17h03
tomlev

pense au bouton :resolu: stp ;)
27/03/2009, 08h21
Hurin

Ha oui, désolé,...