Mutex et CreateProcess

Version imprimable

Bonjour,
J'ai un problème qui est à priori assez simple mais que je n'arrive pas à résoudre.

Ca se passe sous windows en c++ builder mais le pb n'est pas spécifique à builder.

J'ai un Processus principale qui lance un autre processus. Ce 2ème processus lance un 3ème processus et quitte immédiatement.

J'aimerais pouvoir faire en sorte que mon processus principale attende la fin du 3ème processus pour poursuivre son execution.
Comment dois-je faire ?

Actuellement j'ai dans mon processus principale ceci :

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
 
// Création du mutex
HANDLE hMutexFrontReplica = CreateMutex(NULL,FALSE,"REPLICA_FRONT_MUTEX");
 
// Lancement du 2ème processus
STARTUPINFO startupInfo;
PROCESS_INFORMATION procInfo;
memset(&startupInfo, 0, sizeof(STARTUPINFO));
memset(&procInfo, 0, sizeof(PROCESS_INFORMATION));
startupInfo.cb = sizeof(STARTUPINFO);
startupInfo.lpReserved = NULL;
startupInfo.dwFlags = STARTF_USESHOWWINDOW;
startupInfo.wShowWindow = SW_SHOWNORMAL;
 
CreateProcess( NULL,
                "processus2.exe",
                NULL,
                NULL,
                FALSE,
                NORMAL_PRIORITY_CLASS,
                NULL,
                NULL,
                &startupInfo,
                &procInfo);
 
// J'attends la fin du 2eme processus
WaitForSingleObject(procInfo.hProcess,INFINITE)
 
// J'attends la fin du 3eme processus
if(hMutexFrontReplica)
    WaitForSingleObject(hMutexFrontReplica,INFINITE);

Dans mon 2eme processus :

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
 
HANDLE handle = OpenMutex(MUTEX_ALL_ACCESS,TRUE,"REPLICA_FRONT_MUTEX");
// Passage en état non signalé
if(handle){
  HRESULT hr = WaitForSingleObject(handle,INFINITE);
}
// Création du 3eme processus
STARTUPINFO startupInfo;
PROCESS_INFORMATION procInfo;
memset(&startupInfo, 0, sizeof(STARTUPINFO));
memset(&procInfo, 0, sizeof(PROCESS_INFORMATION));
startupInfo.cb = sizeof(STARTUPINFO);
startupInfo.lpReserved = NULL;
startupInfo.dwFlags = STARTF_USESHOWWINDOW;
startupInfo.wShowWindow = SW_SHOWNORMAL;
 
CreateProcess( NULL,
                "processus3.exe",
                NULL,
                NULL,
                FALSE,
                NORMAL_PRIORITY_CLASS,
                NULL,
                NULL,
                &startupInfo,
                &procInfo);

Dans le 3ème processus :

Code:

1
2
3
4
5
 
HANDLE handle = OpenMutex(MUTEX_ALL_ACCESS,FALSE,"REPLICA_FRONT_MUTEX");
if(handle != NULL){
  ReleaseMutex(handle);
}

19/06/2009, 10h05
Médinoc

Qu'en est-il du second processus?
19/06/2009, 10h31
Quaker

Oups j'avais oublié le code du 3ème processus.

Merci d'avance
19/06/2009, 11h37
mehdi_me85
Citation:

J'aimerais pouvoir faire en sorte que mon processus principale attende la fin du 3ème processus pour poursuivre son execution.
Comment dois-je faire ?

Tu crée un évenement dans tes deux processus et tu met dans tin processuss principal :
Code:

1 2 ::WaitForSingleObject(_Monevent,INFINITE); ::ResetEvent(_Monevent);
et tu lance cet évenement à la fin de l'exécution de ton 3éme process
Code:

1 2 ::SetEvent(_Monevent);
Bon courage.
19/06/2009, 12h11
Quaker

Merci mehdi pour ta réponse j'essaie ca de suite...

Nickel ! Ca marche !
Voici le code modifié :

Principal :

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
 
// Création de l'évènement non signalé au démarrage
HANDLE handle = CreateEvent(
        NULL,
        FALSE,	// flag for manual-reset event
        FALSE,	// flag for initial state
        "REPLICA_FRONT_END_EVT" 	// pointer to event-object name
      );
 
// Lancement du 2ème processus
STARTUPINFO startupInfo;
PROCESS_INFORMATION procInfo;
memset(&startupInfo, 0, sizeof(STARTUPINFO));
memset(&procInfo, 0, sizeof(PROCESS_INFORMATION));
startupInfo.cb = sizeof(STARTUPINFO);
startupInfo.lpReserved = NULL;
startupInfo.dwFlags = STARTF_USESHOWWINDOW;
startupInfo.wShowWindow = SW_SHOWNORMAL;
 
CreateProcess( NULL,
                "processus2.exe",
                NULL,
                NULL,
                FALSE,
                NORMAL_PRIORITY_CLASS,
                NULL,
                NULL,
                &startupInfo,
                &procInfo);
 
// J'attends la fin du 2eme processus
WaitForSingleObject(procInfo.hProcess,INFINITE)
 
// J'attends la fin du 3eme processus
WaitForSingleObject(handle,INFINITE);
ResetEvent(handle);

// 2eme processus

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
// Création du 3eme processus
STARTUPINFO startupInfo;
PROCESS_INFORMATION procInfo;
memset(&startupInfo, 0, sizeof(STARTUPINFO));
memset(&procInfo, 0, sizeof(PROCESS_INFORMATION));
startupInfo.cb = sizeof(STARTUPINFO);
startupInfo.lpReserved = NULL;
startupInfo.dwFlags = STARTF_USESHOWWINDOW;
startupInfo.wShowWindow = SW_SHOWNORMAL;
 
CreateProcess( NULL,
                "processus3.exe",
                NULL,
                NULL,
                FALSE,
                NORMAL_PRIORITY_CLASS,
                NULL,
                NULL,
                &startupInfo,
                &procInfo);

// 3eme processus

Code:

1
2
3
4
5
6
 
// Signaler l'evt
HANDLE handle = OpenEvent(EVENT_ALL_ACCESS ,FALSE,"REPLICA_FRONT_END_EVT");
if(handle){
  SetEvent(handle);
}

19/06/2009, 14h43
3DArchi

Salut,
Question bête : si ton programme ressemble peu ou prou à ce que tu présentes, quel est l'intérêt d'attendre la fin du second process dans le premier ? Autant attendre directement ton évènement ?

Biensur ca reviendrait au même.
Par contre je me demandais si le processus 2 ou 3 plante comment je peux le detecter et éviter de rester bloquer dans le processus principale ?

Sinon voici le code corrigé du processus principale :

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
 
 
// Création de l'évènement non signalé au démarrage
HANDLE handle = CreateEvent(
        NULL,
        FALSE,    // flag for manual-reset event
        FALSE,    // flag for initial state
        "REPLICA_FRONT_END_EVT"     // pointer to event-object name
      );
 
// Lancement du 2ème processus
STARTUPINFO startupInfo;
PROCESS_INFORMATION procInfo;
memset(&startupInfo, 0, sizeof(STARTUPINFO));
memset(&procInfo, 0, sizeof(PROCESS_INFORMATION));
startupInfo.cb = sizeof(STARTUPINFO);
startupInfo.lpReserved = NULL;
startupInfo.dwFlags = STARTF_USESHOWWINDOW;
startupInfo.wShowWindow = SW_SHOWNORMAL;
 
CreateProcess( NULL,
                "processus2.exe",
                NULL,
                NULL,
                FALSE,
                NORMAL_PRIORITY_CLASS,
                NULL,
                NULL,
                &startupInfo,
                &procInfo);
 
 
// J'attends la fin du 3eme processus
WaitForSingleObject(handle,INFINITE);
ResetEvent(handle);

19/06/2009, 15h17
3DArchi

Citation:

Envoyé par Quaker

Biensur ca reviendrait au même.
Par contre je me demandais si le processus 2 ou 3 plante comment je peux le detecter et éviter de rester bloquer dans le processus principale ?

Trappe les exceptions au plus au niveau de P2 et P3 et prévoie une notification vers P1 dans ce cas. Cependant, cela ne te garantie pas si P2 ou P3 est sauvagement tué (panneau de contrôle) ou s'il quitte explicitement.
Mets des timers dans tes fonctions d'attente dans un premier temps. Si ton timer claque avant d'avoir ta réponse, tu peux subodorer un problème.
Plus complexe : tu peux associer ton timer avec un système de notification pour faire un watchdog logiciel : à intervalle régulier P1 demande à P2/P3 "es-tu là". P2/P3 répond. S'il ne répond pas -> plantage.
19/06/2009, 15h40
Quaker

Merci pour ta réponse.
Pour les exceptions elles sont bien sur trappé au plus au niveau et dans mon catch j ai aussi bien dans proc2 & 3 l'envoi de l'évènement.

Sinon j'ai opté grossièrement pour la solution suivante(le - gourmand en code) :
_les proc2 & 3 créent un mutex du même nom
_dans le proc principale j'ai mis le WaitForSingleObject dans une boucle avec un timeout
Si WaitForSingleObject me retourne WAIT_TIMEOUT je teste la présence de ce mutex. S'il n'existe plus cela veut dire que proc2 & 3 sont mort et donc que je peux continuer mon exécution