Problème lors de lancement de process en multithread

Bonjour à tous,

voici mon soucis :

Je lance en même temps (à la millisecondes prêt) deux fois le même executable en variant des paramètres d'entrées du process dans deux threads différents . Même si un thread fini de travailler avant l'autre, il attendra que l'autre soit terminé avant de lancer le prochaine executable.
Je vous avouerai que je reste très perplexe ?8O?!8O!

Il y a un mutex positionné sur une méthode qui permet de gérer la concurrence d'accès à un fichier en écriture car les deux process peuvent ecrire sur un même fichier. J'ai vérifié , celui ci est bien libérer à la fin de la méthode à l'intérieur d'un "finally".

Est ce qqun aurait une idée qui exliquerait cette attente entre les threads alors qu'ils sont censé travaillé chacun de leur coté??
Le fait qu'il soit lancé au même instant ( à la millisecondes prêt) n'influe t'il pas directement sur la gestion du multithread de l'OS ???

merci d'avance pour votre aide ;)

Peux-tu nous montrer le code du lancement des process par tes threads ?

(et puis je doute que l'OS ai du mal à gérer 2 threads ;))

Citation:

---

et puis je doute que l'OS ai du mal à gérer 2 threads

---

lol je suis bien d'accord avec toi mais je ne vois tellement pas d'ou ca vient que je me mets à me pauser des questions mystics.


Je ne peux pas te donner le code exact de mémoire mais voici le principe:

Sur mon serveur, je possède un fichier .cmd qui lui contient ni plus ni moins que la commande dos qui permet d'appeler l'executable en ligne de commande.

C'est ce fichier qui est appelé dans mes deux threads via un objet

Code:

---

Process p = new Process()

---

depuis le code .Net avec des arguments différents liés au process pour chaque appelle.

A chaque appelle au fichier CMD et pour chaque threads je fais bien un

Code:

---

new

---

pour le process.

Lors que je regarde ma liste des taches, j'ai bien deux fois mon process "xxxxx.exe" et lorsque le premier se termine je n'en ai plus qu'un. Jusqu'ici rien d'anormal ;).

Ce qui est étrange c'est que le thread qui vient de terminer l'exécution du process, devrait en lancer un autre: "yyyyyy.exe".
Il ne le fait que lorsque que le second thread à terminer l'execution de son process "xxxxx.exe".

Donc du coup au lieu d'avoir dans ma liste des taches en même temps :
-"xxxxx.exe"
-"yyyyyy.exe"

je les ai les uns à la suite des autres.

je ne sais pas si je suis très clair

Si tu rajoutes un MessageBox.Show pile au moment où un des process s'arrête (directement après le p.WaitMachin, sans try ni finaly ni rien entre les deux), ça te donnes quoi ?

Je te dirai ca demain matin , mais je t'avouerai que je ne vois pas trop ou tu veux en venir ??
Le message va forcément s'afficher sauf s'il ya une exception à la sortie du process nan ?

merci pour ton aide en tout cas.

Bah en fait si à chaque fois ton thread c'est Process.Start et Process.WaitForExit, normalement cela devrais marcher et peut être que le blocage survient plus loin dans ton code, mais toujours dans le thread (vu que j'ai pas le code, j'émet des suppositions, il faudrait voir le code qui démarre le Process et attend la fin de son exécution).
Par contre si avec des MessageBox ou alors via le debug tu constates qu'effectivement le premier Process.WaitForExit ne se termine pas tant que le deuxième Process ne s'est pas terminé, ça devient différent car l'incohérence viendrait de la classe Process et là ... il faudrait improviser.

J'utilise effectivement Process.Start et Process.WaitForExit.

Le process se termine forcément correctement puisque dans la barre des taches windows au début il y a deux process "xxxxxxx.exe" puis après un seul.Ou alors il y a un soucis entre le moment ou mon fichier de commande DOS termine l'execution du process et le moment ou mon process DOS lui même se termine.

Perso je pense que ca vient plus du code de mon thread. Les deux threads en questions possèdent exactement le même code et appelle la même méthode sauf que ces deux threads travaillent avec deux instances différentes du même Objet.

Je regarde ca de plus pret demain.

Merci ;)

J'utilise effectivementles methodes Start et WaitForExit mais sur cette seconde je mets un temps en millisecondes pour attendre avant de sortir.

J'imagine que si le process se termine avant le temps passer en parammètres le process s'arrete ??

Citation:

---

Envoyé par msdn

La surcharge WaitForExit(Int32) est utilisée pour faire attendre le thread en cours jusqu'à l'arrêt du processus associé. Cette surcharge demande au composant Process d'attendre pendant un laps de temps limité que le processus s'arrête. Si le processus associé ne s'arrête pas au terme de cet intervalle après le rejet de la requête d'arrêt, false est retourné à la procédure d'appel. Vous pouvez spécifier un nombre négatif pour milliseconds, mais il est traité par WaitForExit(Int32) en tant que nombre positif très élevé. Si vous passez 0 (zéro) à la méthode, elle retourne true uniquement si le processus s'est déjà arrêté.

---

Perso j'utilise WaitForExit(), pas WaitForExit(Int32)

Bonjour et merci pour ta réponse.

En fait je viens de tester le lancement des mes deux process avec un décalages de 30ms entre les deux et ce coup ci, tout fonctionne normalement, la parallélisme s'effectue correctement les deux process
"XXXXXX.exe" se lance avec un décalage de 30 ms l'un s'arrete lance les autre process pendant que le premier continue d'executer son process xxxxx.exe".

Je resteste en enlevant le timeout et je vous tiens au courant.

a+

J'avais penser au fait que parmi l'ensemble des méthodes appelées dans mes deux threads certaines étaient statics (commune aux deux threads) et NOTAMMENT celle qui permet de lancer le Process. Autrement dit celle qui manipule l'objet Process Start WaitForExit.

J'ai, pour tester, copiée cette méthode dans la classe objet manipuler dans mes threads pour ne plus l'appeler en static. Le resultat est le même, l'execution ne se fait pas en parralèle.


Au final , j'ai trouvé deux solutions :
- Espacé les lancement des mes process de "X" ms
- Ne pas utiliser le WaitForExit(Int 32) mais le WaitForExit() pour attendre la fin du process.

Cela reste qd meme étrange, je pense qu'il y a certainement une autre raison dans le code de mes threads qui m'echappe.


Merci pour ton aide smiley ;)