PureBasic

Bonjour à tous

Comment utiliser au mieux les instructions Thread dans les boucles imbriqués.
La dans l'exemple se serait pour utiliser un Thread pour la segonde boucle.
Je me suis basé sur des exemples du forum, est'il obligatoire de passer par une procedure pour utiliser les Threads ?

Code : Tout sélectionner

; TEST THREAD
j.l : i.l : j.l : k.l
Global total.l
Global total1.l
total = 0 : total1 = 0
;
Procedure a(a)  
  ;  
  For k = 1 To 100000
    total = (i+k) * 2   
  Next k 
  ;
  ProcedureReturn total

EndProcedure
;
;============================
; Boucle normale 
;
For i = 1 To 10
   For j = 1 To 100000
     total1= (i+j) * 2  
   Next j
Next i
;
;============================
; Boucle Thread
;
For i = 1 To 10    
  CreateThread(@a(), 0) 
Next i
;
;
Debug "_________________________________________"
Debug " Boucle Normale = "  +Str(total1)
Debug " Boucle Thread  = "  +Str(total)
Debug "_________________________________________"

+

Bonjour,
Je t'invite à lire ce post explicatif de Falsam, ça devrait t'aider.
http://www.purebasic.fr/french/viewtopi ... =6&t=11872

Dans ton exemple, tu crees x fois le même thread, je ne pense pas que ce soit judicieux.

Bonjour Ar-s

Merci pour le lien avec les explicatif de Falsam.
Sur les Thread , un autre topic du forum (entre autres) se rapproche de ce que je tente de realiser.

http://www.purebasic.fr/french/viewtopi ... lit=thread

Le code que donne GallyHC est pas loin.
Mais si on affiche les résultats hors procédure c'est idem que mon code , les resultats ne tombent pas bon

Code : Tout sélectionner

Procedure a(a)
	For aa = 1 To 100
		Debug "aa " + Str(aa)
		Delay(100)
	Next
EndProcedure

Procedure b(b)
	For bb = 1 To 100
		Debug "bb " + Str(bb)
		Delay(100)
	Next
EndProcedure

Procedure c(c)
	For cc = 1 To 100
		Debug "cc " + Str(cc)
		Delay(100)
	Next
EndProcedure

Procedure d(d)
	For dd = 1 To 100
		Debug "dd " + Str(dd)
		Delay(100)
	Next
EndProcedure

CreateThread(@a(), 0)
CreateThread(@b(), 0)
CreateThread(@c(), 0)
WaitThread(CreateThread(@d(), 0))

Debug aa
Debug bb
Debug cc

Essaye comme ça :

Code : Tout sélectionner

Global.l aa,bb,cc,dd

Procedure a(a)
  aa = 1
  Repeat
    Debug "aa = " + Str(aa)
    Delay(90)
    aa + 1
  Until aa = 10
  ProcedureReturn aa
EndProcedure

Procedure b(b)
  bb = 1
  Repeat
    Debug "bb = " + Str(bb)
    Delay(95)
    bb + 1
  Until bb = 10
  ProcedureReturn bb 
EndProcedure

Procedure c(c)
  cc = 1
  Repeat
    Debug "cc = " + Str(cc)
    Delay(98)
    cc + 1
  Until cc = 10
  ProcedureReturn cc
EndProcedure

Procedure d(d)
  dd = 1
  Repeat
    Debug "dd = " + Str(dd)
    Delay(100)
    dd + 1
  Until dd = 10
  ProcedureReturn dd
EndProcedure

Ta = CreateThread(@a(), a)
Tb = CreateThread(@b(), b)
Tc = CreateThread(@c(), c)
Td = CreateThread(@d(), d)

If Ta
  If Tb
    If Tc
      If Td

        WaitThread(Td)
        
        Debug aa
        Debug bb
        Debug cc
        Debug dd
        
      EndIf
    EndIf
  EndIf
EndIf

Merci AR-S pour le code et le correctif.

Et sinon l'exemple de la doc sur les mutex, ne correspond pas à ce que tu veux faire ?

Code : Tout sélectionner

; Executez ce programme une fois comme il se présente. Vous verrez que les lignes imprimées seront
; mélangées entre les threads. Maintenant supprimez les commentaires devant les commandes de Mutex
; et les chaînes seront imprimées dans l'ordre, car un seul thread à la fois
; sera autorisé à exécuter les commandes d'impression.
;
Procedure SansMutex(*Numero)     
      Shared Mutex
      
      For a = 1 To 5      
            LockMutex(Mutex)    ; supprimez le commentaire pour voir la différence
            
            PrintN("Thread "+Str(*Numero)+" essaie d'imprimer 5 fois a la suite :")
            For b = 1 To 5
                  Delay(50)
                  PrintN("Thread "+Str(*Numero)+" Ligne "+Str(b))
            Next b          
            
            UnlockMutex(Mutex)  ; supprimez le commentaire pour voir la différence
      Next a    
EndProcedure

OpenConsole()
Mutex = CreateMutex()

thread1 = CreateThread(@SansMutex(), 1)
Delay(25)
thread2 = CreateThread(@SansMutex(), 2)
Delay(25)
thread3 = CreateThread(@SansMutex(), 3)

WaitThread(thread1)
WaitThread(thread2)
WaitThread(thread3)

Input()

Sinon le soldat inconnu avait fait un code expliquant un peu les Mutex, mais je n'ai pas pu remettre la patte dessus.

Bonjour à tous.

Merci Geo Trouvpatou pour l'exemple sur les mutex.
(se sont mes premieres tentatives sur les Thread/Mutex/Semaphore)

Dans les exemples cités et interressants, les procedures effectuent un nombre de boucles
à l'interieur et renvoient le resultat.

Mon utilisation des Thread, ferait plutot que la Procedure/Thread,
soit en fin d'une grosse boucle, effectue son traitement
et affiche une sorte de "Compteur" à chaque passage de Boucle .

Remise à jour du code,
Bon apparement, obligation de créer le Thread à chaque début de boucle Finale ?
Serais ce la bonne maniere ?

Code : Tout sélectionner

; ; Thread Dans Boucle // LinkedList
;DisableDebugger 
Global a.l ,b.l,z.l,j.l
Global Total.l
Global col.l = 100
Global lignes.l = 100000
Global Dim TBL.l(col,lignes)
Global Controle.l = 100
;======================= Remplir Tableau TEST
For a = 1 To col  
	For b = 1 To lignes
		TBL(a,b) = Random(1) 
	Next b 
Next a
; ====================== Liste chainée de Longueur Aleatoire
Global NewList ADRESSE.l()
Global Colonne.l  
Global Longueur.l  
; Remplir les Adresses
Longueur = Random(lignes)  
Debug "Longueur = " +Str(Longueur) 
;
For z = 1 To Longueur  
	AddElement(ADRESSE())
	ADRESSE() = Random(Longueur)
Next z
Debug "Taille Liste = " +Str(ListSize(ADRESSE())) 
Debug "============================================="
;
; Procedure de Comptage Adresses Du tableau
;
Procedure Count(a)
	;
	ForEach ADRESSE()        
		Total + TBL(Colonne,ADRESSE()) ; 
	Next	
	;
	EnableDebugger   
	;
	;Debug " TRHEAD  =  " +Str(j) + "  Colonne  = " +Str(Colonne)
	Debug " TRHEAD  =  " +Str(j) + "  Colonne  = "+Str(Colonne) +"  TOTAL =  " +Str(Total) 
	;	
	DisableDebugger 
	;
	Total = 0 
EndProcedure
;Ta = CreateThread(@Count(), a)
;
For j = 1 To 3000 
  ;
  Ta = CreateThread(@Count(), a)
  ;ResumeThread(Count)
  Colonne.l = Random(99) +1
  ;EnableDebugger 
  ;Debug " TRHEAD  =  " +Str(j) + "  Colonne  = " +Str(Colonne)
	;EnableDebugger 	
WaitThread(Ta)  
;
Next j
;
EnableDebugger 
;
Debug "============================================="
Debug "Boucle Longueur = " +Str(j-1)
Debug "Longueur = " + Str(Longueur)
Debug "Taille Liste = " +Str(ListSize(ADRESSE())) 
;
;

PureBasic

Boucle & Thread

Boucle & Thread

Re: Boucle & Thread

Re: Boucle & Thread

Re: Boucle & Thread

Re: Boucle & Thread

Re: Boucle & Thread

Re: Boucle & Thread