Plusieurs Thread exécutant des requêtes qui se terminent tous au même moment (quand le plus lent a terminé)

**jlbrd** · 22/06/2022, 10h08

Bonjour,

Pour renseigner un tableau de bord, j’ai besoin d’exécuter plusieurs requêtes simultanément qui ne doivent pas bloquer l’interface et qui doivent afficher leur résultat dès que le requête est terminée. Pour cela j’utilise des thread. Mon problème est que lorsque plusieurs thread exécutant des requêtes sont lancés, ils se terminent tous lorsque le plus lent a terminé.

Exemple avec un bouton mettant à jour un champ de saisie :

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
 
SAI_LOG = ""
ThreadExécute("t1", threadNormal, cal1)
ThreadExécute("t2", threadNormal, cal2)
 
	PROCÉDURE INTERNE cal1()
		dhDebut1 est un DateHeure = HeureSys()
		moMontant1 est un monétaire
		qQuery1 est une Requête SQL = 
		[
			SELECT SUM(MATABLE1.Montant) 
			FROM MATABLE1
			WHERE MATABLE1.Date > '01/05/2022'
		]
 
		SI HExécuteRequête(qQuery1, Cnx, hRequêteSansCorrection) ALORS
			HLitPremier(qQuery1,hForwardOnly+hSansRafraîchir)
			SI PAS HEnDehors(qQuery1)
				moMontant1 = qQuery1.Montant
			FIN
		SINON
			Erreur("Erreur Exécution Requête",HErreurInfo(hErrComplet))
		FIN
		HLibèreRequête(qQuery1)
		ExécuteThreadPrincipal(maj, dhDebut1, DateHeureSys(), moMontant1)
	FIN
 
	PROCÉDURE INTERNE cal2()
		dhDebut2 est un DateHeure = HeureSys()
		moMontant2	est un monétaire
		qQuery2		est une Requête SQL	= 
		[
			SELECT SUM(MATABLE2.Montant) 
			FROM MATABLE2
			WHERE MATABLE2.Date > '01/05/2022'
		]
 
		SI HExécuteRequête(qQuery2, Cnx, hRequêteSansCorrection) ALORS
			HLitPremier(qQuery2,hForwardOnly+hSansRafraîchir)
			SI PAS HEnDehors(qQuery2)
				moMontant2 = qQuery2.Montant
			FIN
		SINON
			Erreur("Erreur Exécution Requête",HErreurInfo(hErrComplet))
		FIN
		HLibèreRequête(qQuery2)
		ExécuteThreadPrincipal(maj, dhDebut2, DateHeureSys(), moMontant2)
	FIN
 
	PROCÉDURE INTERNE maj(LOCAL P_heureDebut1 est un DateHeure, LOCAL P_heureDebut2 est un DateHeure, P_val est un monétaire )
		SAI_LOG += RC + "Heure debut 1: " + P_heureDebut1+ " Heure debut 2: " + P_heureDebut2 + " Valeur : " + P_val + " Heure procédure " + DateHeureSys()
	FIN

La première requête est très rapide alors que la deuxième met plusieurs secondes pourtant les deux valeurs sont affichées en même temps ce qui signifie que les deux thread se termine quand le plus lent a terminé.

Ci-dessous un même test mais sans requête. Cette fois ça fonctionne correctement :

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
 
SAI_LOG = ""
ThreadExécute("t1", threadNormal, cal1)
ThreadExécute("t2", threadNormal, cal2)
 
	PROCÉDURE INTERNE cal1()
		dhDebut1 est un DateHeure = HeureSys()
		moMontant1 est un monétaire = 100.10
		ExécuteThreadPrincipal(maj, dhDebut1, DateHeureSys(), moMontant1)
	FIN
 
	PROCÉDURE INTERNE cal2()
		dhDebut2 est un DateHeure = HeureSys()
		moMontant2	est un monétaire = 300.33
		Temporisation(200)
		ExécuteThreadPrincipal(maj, dhDebut2, DateHeureSys(), moMontant2)
	FIN
 
	PROCÉDURE INTERNE maj(LOCAL P_heureDebut1 est un DateHeure, LOCAL P_heureDebut2 est un DateHeure, P_val est un monétaire )
		SAI_LOG += RC + "Heure debut 1: " + P_heureDebut1+ " Heure debut 2: " + P_heureDebut2 + " Valeur : " + P_val + " Heure procédure " + DateHeureSys()
	FIN

Je pense donc que c’est lié à un problème de contexte HFSQL mais je ne sais pas comment régler le problème. J’ai testé aussi avec TâcheParallèleExécute et c’est le même problème.

Quelqu’un a-t-il une idée ?

Merci et bonne journée

**mous97** · 22/06/2022, 10h50

Salut, je peux te donner une autre piste pour ton cas d'utilisation qui peut te faire éviter les threads

Exécuter tes requêtes avec les fonctions asynchrones

https://doc.pcsoft.fr/fr-FR/?1000026094

**jlbrd** · 22/06/2022, 11h09

Oui en fait j'ai déjà testé cette possibilité :

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
 
SAI_LOG = ""
cal1()
cal2()
 
	PROCÉDURE INTERNE cal1()
		qQuery1 est une Requête SQL = 
		[
			SELECT SUM(MATABLE1.Montant) 
			FROM MATABLE1
			WHERE MATABLE1.Date > '01/05/2022'
		]
 
		SI HExécuteRequêteAsynchrone(qQuery1, Cnx, hRequêteDéfaut, _setMontant) ALORS
		SINON
			pDB.CatchError("Erreur Exécution Requête",HErreurInfo(hErrComplet))
		FIN
		HLibèreRequête(qQuery1)
	FIN
 
	PROCÉDURE INTERNE cal2()
		qQuery2		est une Requête SQL	= 
		[
			SELECT SUM(MATABLE2.Montant) 
			FROM MATABLE2
			WHERE MATABLE2.Date > '01/05/2022'
		]
 
		SI HExécuteRequêteAsynchrone(qQuery2, Cnx, hRequêteDéfaut, _setMontant) ALORS
		SINON
			pDB.CatchError("Erreur Exécution Requête",HErreurInfo(hErrComplet))
		FIN
		HLibèreRequête(qQuery2)
	FIN
 
	PROCÉDURE INTERNE _setMontant(monenr est un Enregistrement)
		SAI_LOG += RC + monenr.Montant
	FIN

Et en fait c'est la même chose. L'affichage est mis à jour lorsque la plus lente des deux requêtes a terminé.

**mous97** · 22/06/2022, 11h41

Code :

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

1
2
3
4
5
6
 
 
		SI HExécuteRequêteAsynchrone(qQuery1, CnxLOGeCOM, hRequêteDéfaut, _setMontant) ALORS
		SINON
			pDB.CatchError("Erreur Exécution Requête",HErreurInfo(hErrComplet))
		FIN

Je n'ai pas trop de piste mais on peut essayer quelque chose
Et si tu utilisais 2 méthodes _setMontant1 et _setMontant2 propre à chaque HExecuteRequêteSQLAsynchrone plutôt qu'une ?

**jlbrd** · 22/06/2022, 12h33

Et si tu utilisais 2 méthodes _setMontant1 et _setMontant2 propre à chaque HExecuteRequêteSQLAsynchrone plutôt qu'une ?

Non pas mieux

**mous97** · 22/06/2022, 12h51

Envoyé par jlbrd

Non pas mieux

Je sèche alors je n'ai aucune piste pour toi désolé

**mous97** · 22/06/2022, 12h53

Si ton code est exécuté dans le traitement d'initialisation de la fenêtre, essaye de l'exécuter en fin d'initialisation de la fenêtre ?

**Voroltinquo** · 22/06/2022, 13h06

Bonjour,
Des pistes en vrac..

-Qu'est-ce que ça donne si tu inverses l'appel des thread ?

Code :

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

1
2
3
 
ThreadExécute("t2", threadNormal, cal2)
ThreadExécute("t1", threadNormal, cal1)

à la place de

Code :

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

1
2
3
 
ThreadExécute("t1", threadNormal, cal1)
ThreadExécute("t2", threadNormal, cal2)

-As-tu tenté de forcer l'arrêt via threadFin avant l'appel de ton thread principal ?
-As-tu tenté l'envoie d'un signal à ton thread principal (à la place du ThreadExécute ?)

Personnellement la dernière solution "me parle"

**jlbrd** · 22/06/2022, 13h56

Bonjour, alors dans chacune des deux procédures j'ai commenté ExécuteThreadPrincipal et mis une trace:

Code :

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

1
2
3
4
 
		Trace(DateHeureSys(), moMontant1)
		ThreadFin()
		//ExécuteThreadPrincipal(maj, dhDebut1, DateHeureSys(), moMontant1)

L'appel du thread principal n'est plus appelé pourtant ça ne fonctionne pas mieux. Pareil en inversant les appels t1 et t2. La DateHeure affichée a exactement la même valeur dans les deux lignes de trace.

**mous97** · 22/06/2022, 13h59

Envoyé par jlbrd

Bonjour, alors dans chacune des deux procédures j'ai commenté ExécuteThreadPrincipal et mis une trace:

Code :

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

1
2
3
4
 
		Trace(DateHeureSys(), moMontant1)
		ThreadFin()
		//ExécuteThreadPrincipal(maj, dhDebut1, DateHeureSys(), moMontant1)

L'appel du thread principal n'est plus appelé pourtant ça ne fonctionne pas mieux. Pareil en inversant les appels t1 et t2. La DateHeure affichée a exactement la même valeur dans les deux lignes de trace.

Tu as essayé d’exécuter ton code en fin d'initialisation de la fenêtre ?

**jlbrd** · 22/06/2022, 14h05

Je suis dans le code d'un bouton

**frenchsting** · 22/06/2022, 14h16

Bonjour,

D'après ce que tu as dis, cal1 est rapide. Dans ce cas, pourquoi ne pas faire ceci :

Code :

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

1
2
3
4
5
6
sablier(vrai)
ThreadExécute("t2", threadNormal, cal2)
cal1()
Multitacherepeint(mafenêtre)
multitâche(-1)
sablier(faux)

Tu lances le traitement long en "arrière plan". Pendant ce temps, le traitement rapide s'affiche (ou presque).

A tester, bien sûr...

**jlbrd** · 22/06/2022, 16h19

Oui ta proposition devrait fonctionnement. Mais dans l'exemple j'ai 2 requêtes, en réalité c'est environ une dizaine qui va être lancée sans qu'on puisse prévoir leur temps d'exécution

**Narwe** · 23/06/2022, 08h43

Peut-être en essayant un autre paramètre que ThreadNormal, je pense à threadUtiliseHFSQL ?

Peut-être en essayant avec une "vrai" procédure plutôt qu'une procédure interne ? J'aime beaucoup les procédures internes mais peut-être qu'il y a un mode de fonctionnement qui fait cela provoque ce blocage.

Peut-être en faisant un code beaucoup moins propre et compréhensible et au lieu d'avoir des threads, avoir des OuvreSoeur (ou OuvreFille) de fenêtres cachées qui exécute chacun des thread ?

**frenchsting** · 23/06/2022, 09h00

+1 @Narwe (tiens un revenant

)

Une autre idée (pour tester), c'est de lancer des procédures (locales ou globales) via des timers (timersys) ou ceux gérés directement par Windev (dans l'éditeur de code)

**mous97** · 23/06/2022, 10h47

Au point ou on en est je balance des idées comme ça

Essaye de ne pas lancer un HLibèreRequête à la fin ?
Essaye de passer par des requêtes créée dans le projet ?

**Voroltinquo** · 24/06/2022, 15h40

A priori, tu as zappé la solution du signal.

On va utiliser 2 signaux, siSynchro qui va s'assurer que le thread principal est bien prêt à traiter le résultat des thread secondaire, et siFinThread qui va être envoyé par un thread secondaire lorsque son traitement sera terminé et avertira le thread principal qu'il peut traiter le résultat.
Par ailleurs afin d'éviter une perte de résultat consécutive à des fins de traitement simultanée, on enfilera les threads secondaires (l'ordre dans lequel il auront été terminé sera alors conservé)

Le code est le suivant :

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
 
PROCÉDURE TrPrincipal()
nCompteurThread	est entier
saNomProc		est chaîne
saMsg est chaîne
 
siSynchro est un SignalManuel
siFinThread est un SignalManuel
liThreadsTerminés est File de chaîne
 
ThreadExécute("tCourt",threadNormal,ProcLongue,liThreadsTerminés,siSynchro,siFinThread)
ThreadExécute("tLong",threadNormal,ProcCourte,liThreadsTerminés,siSynchro,siFinThread)
SignalOuvre(siSynchro) //On lance les threads simultanément
 
nCompteurThread=1
TANTQUE nCompteurThread<=2
	SignalAttend(siFinThread)
	SignalFerme(siFinThread)//On arrête d'enfiler les résultat de fin
        //On traite les résultats des threads
	TANTQUE liThreadsTerminés..Occurrence>0
		Défile(liThreadsTerminés,saNomProc)
		saMsg=ChaîneConstruit("Thread n° %1, (%2) est terminé",nCompteurThread,saNomProc)
		ToastAffiche(saMsg)
		Trace(saMsg)
		nCompteurThread++
	FIN
FIN

Code :

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

1
2
3
4
5
6
 
PROCÉDURE ProcCourte(liThreads est File de chaînes, siDépart est un SignalManuel,siFin est un SignalManuel)
SignalAttend(siDépart)	//Attend que tous les threads soient prêts
ThreadPause(100)	//Corps du thread
Enfile(liThreads,"ProcCourte")
SignalOuvre(siFin)	//On prévient de la fin du thread

Code :

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

1
2
3
4
5
6
 
PROCÉDURE ProcLongue(liThreads est File de chaînes, siDépart est un SignalManuel,siFin est un SignalManuel)
SignalAttend(siDépart)
ThreadPause(200)
Enfile(liThreads,"ProcLongue")
SignalOuvre(siFin)

On voit que si l'on change la valeur de la pause de 100 à 300 dans ProcCourte, ProcCourte est traitée après ProcLongue

**jlbrd** · 26/06/2022, 02h13

Bonjour @Voroltinquo,

Ta solution fonctionne tant que tu mets des temporisation dans tes deux threads. Le problème est toujours le même car lorsque l'on exécute des requêtes SQL dans tes threads, toutes les requêtes renvoient leur résultat lorsque le requête la plus lente est terminée et pas avant. Du coup les deux threads eux aussi se terminent en même temps.

Donc la question ce n'est pas la façon d'utiliser les threads mais pourquoi ces requêtes sont bloquées tant qu'une est encore en train de s'exécuter ? Il doit y avoir une limitation du framework et/ou du driver utilisé (SQLOLEDB) mais rien n'est documenté à ce sujet.

Merci et bonne journée

**tbc92** · 26/06/2022, 10h44

Ca va être difficile à tester, mais si tu exécutes ces différentes requêtes via des programmes totalement différents, est-ce que tu as le même phénomène ?
L'idée, c'est quoi : c'est que si 2 requêtes attaquent la même table, il peut arriver qu'elles entrent en conflit. La première requête bloque la table, et la 2ème ne commencera que quand la première sera finie. Et si la 2ème est extrêmement courte, tu as l'impression qu'elles finissent en même temps.
C'est assez logique que ça se passe comme ça si certaines requêtes écrivent dans les tables. Ce serait plus surprenant si tes requêtes font toutes de la consultation.

Ici, tu as une application 'professionnelle'. Et tu utilises HFSQL. Peut-être que passer sur du MySQL ou autre pourrait résoudre tes problèmes.

**Voroltinquo** · 26/06/2022, 15h59

Pour revenir sur l'idée de tbc92, même si tes requêtes ne font que de la consultation, il est possible que quelqu'un écrive sur la table pendant ta requête.
Un idée serait de travailler avec des vues initialisées avant l'appel des threads.

Plusieurs Thread exécutant des requêtes qui se terminent tous au même moment (quand le plus lent a terminé)

WinDev

Discussions similaires

Partager

Partager