Discussion :

[Hurin]

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 :

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
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 !

[deejay2221]

As-tu essayé d'utiliser seulement la mot clé lock?
Par exemple :

Code :

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

1
2
3
4
5
6
object barrure;
 
lock (barrure)
{
    // section sensible
}

[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.

[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.

[Gold Bug]

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.

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.

[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,

Je repost dès que j'ai du nouveau, encore merci !

[tomlev]

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...

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

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

Code :

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

1
2
3
4
lock(toto)
{
    // instructions
}

en quelque chose comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
try
{
    Monitor.Enter(toto);
 
    // instructions
 
}
finally
{
    Monitor.Exit(toto);
}

[Hurin]

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

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 !

[tomlev]

pense au bouton stp