Wie lasse ich Prozeduren parallel laufen?

[Froggerprogger]

@MVXA
Ja schon, aber shoam scheint grundlegendere Verständnisprobleme mit Prozeduren zu haben.

Erst wenn ich eine Procedure aufrufe z.B. mit
a()
b()
dann starten sie aber dann laufen sie wieder nicht parallel.

merlin hat das ja schon schön erklärt.
Prozeduren sind im Allgemeinen dazu da, um irgendwelche Funktionen zu berechnen, oder Aktionen auszuführen, sie werden aber nicht gleich ausgeführt, wenn sie definiert werden. Sie können dann einfach durch einen Prozeduraufruf ausgeführt werden.
Das gesamte Programm aber wird normalerweise in einem 'Thread' ausgeführt. Ein 'Thread' ist sowas wie ein 'Aktivitätsträger'. D.h. ein Thread arbeitet stets an nur genau einer Stelle des Programms gleichzeitig. Beim Prozeduraufruf springt er also in die Prozedur, bis er damit fertig ist, und dann wieder heraus, und fährt dort fort, von wo er die Prozedur sprang.

Man kann mit mehreren Threads arbeiten, dabei kann es aber zu vielen Problemen, kommen, wenn die Programmiersprache Threads nicht sicher unterstützt, also diese Probleme von Haus aus vermeidet. PB ist nicht Threadsicher, daher sollte man wo möglich Threads vermeiden. Aber wenn man weiss was man tun muss, dann kann man durchaus auch mit PB mit Threads arbeiten. Aber als Hauptregel sollte hier gelten:
Nutze keine Strings/Stringfunktionen von PB in als Thread laufenden Prozeduren.
Bist du auf Strings angewiesen, nutze die threadssichere Stringlibrary auf purearea.

[PAMKKKKK]

Füge das mal in deinen Purebasic ein und drücke F5

Code: Alles auswählen

; Wozu sind Proceduren da ?
; ein Beispiel von Pamkkkkk
; PB 3.93 14 August 2005

; In Proceduren packt man Code den man immer wieder braucht
; zuerst schreibt man die Procedure die noch nicht ausgefürt wird.
; Sie liegt nun erstmal im Computer speicher und kann dann erst benutzt werden.
Procedure Nachricht(Text.s)
  MessageRequester("Nachricht",Text.s)
EndProcedure

; Hier nun wird die Procedure benutzt (es folgen 3 Aufrufe)

Nachricht("Ich bin der erste aufruf der Procedure") 
Nachricht("Ich bin der zweite aufruf der Procedure")
Nachricht("Ich bin der letzte aufruf der Procedure" +Chr(10) + "Sonnst wirds langweilig.....")

; Proceduren können Rückgabewerte aus berechnungen, oder so haben
; hier eine Procedure die was berechnen soll
Procedure.l Rechne_was(Wert1.l,Wert2.l)
  Wert3 = Wert1 + Wert2
  ProcedureReturn Wert3 ; <<< Gibt den Wert zurück an den Aufrufer
EndProcedure
; Die Variablen Wert1 ,Wert2 und Wert3 kann man nur in innerhalb der Procedure verwenden
; Variablen die in allen Proceduren bakannt sein sollen deklariert man als Global
; Globale Variablen sind nur sehr sparsam (garnicht) zu verwenden

; Hier mal beide Proceduren gemeinsam aufgerufen:

Nachricht("Ich rechne mal was 5 + 6 ist = " + Str(Rechne_was(5,6)))
; die Funktion Str() wandelt zahlen (das ergebnis von Rechne_was) in Buchstaben um

; Proceduren kann man also verschachtet aufrufen dabei wird erst die innerste Procedure ausgeführt und
; die äussere arbeitet mit dem ergebnis weiter
; Proceduren werden also immer hintereinander ausgeführt nicht gleichzeitig !

; Wann Proceduren sinnvoll sind entscheidet der Programmierer für sich selbst!
; Wwenn man einen Codeabschnitt öfter braucht sind Proceduren immer sinnvoll.
; Wenn man was schlaues hat, und es in anderen Codes wiederverwenden will, sind Proceduren ebenfalls sinnvoll.
; Jede Purebasic Funktion (wie z.B. die Str() Funktion) sind eigentlich fertige Proceduren mit einem Rückgabe wert.

Willst du das etwas gleizeitig passiert ist es das einfachste ist 2 *.exe zu Kompilieren die sich genseitig aufrufen.
Etwa so als, Pingpong spiel:

Code: Alles auswählen

 Delay(100)
RunProgram("meine_2te_EXE.exe")

Code: Alles auswählen

 Delay(125)
RunProgram("meine_1te_EXE.exe")

Das geht, ist aber nicht sehr elegant

Besser währe es Zeitgesteuert Proceduren aufzurufen.
Eine Procedur hat die Uhr und Ruft dann die anderen auf:

Code: Alles auswählen

; zum ausführen mit eingeschalteten debugger !
; menü Compiler den Debugger einschalten
; In jaPBe Taste F6 drücken

Procedure.l Rechne_was(Wert1.l,Wert2.l)
  ; Procedure mit Rückgabewert
  Wert3.l = Wert1 +Wert2
  ProcedureReturn Wert3
EndProcedure

Procedure Kleinbuchstaben(Text.s)
  ; Procedure ohne Rückgabewert
Debug "Ich habe keinen Rückgabe Wert! " + LCase(Text) ;<<< Der text wird hier ausgegeben
EndProcedure

; Aufruf durch Hauptprogramm
Repeat
; Wenn eine Ms vergangen ist zähler hochsetzen  
  Delay(1)
  Zaehler =  Zaehler +1
  ; nach 100Ms zeug starten
  If Zaehler = 100
    Debug "Ich rechne 5 + 7 = " + Str(Rechne_was(5,7)) ;<<< Der text wird hier ausgegeben
  EndIf
  ; nach 130Ms zeug starten
  If Zaehler = 130
    Kleinbuchstaben("Dieser TEXT WIRD KLEIN!")
    Zaehler = 0 ; von Vorne beginnen
  EndIf
  ; für das Ende Zählen
  ende = ende +1
  If ende = 650 ; 130*5, also wird das hier 5 mal passieren 
    End ; Heir wird das gesammte Programm beendet
  EndIf
  
ForEver