ermitteln, welcher Thread auf Prozedur zugreift

SBond · Beitrag von **SBond** » 22.09.2014 20:44

Hallo Leute,

kann man herausfinden, welcher Thread auf auf eine Prozedur zugreift? Dabei spielt es keine Rolle, ob es der Hauptthread ist oder irgend ein anderer. Ich bräuchte nur so eine Art ID, um verschiedene Threads voneinander zu unterscheiden.

Ich habe folgendes vor....
Damit ich später mögliche Programmfehler besser lokalisieren kann (während der Laufzeit), entwerfe ich ein Logging-System. Dabei werden in die Logdatenbank verschiedene Daten über den Programmablauf protokolliert. Unter anderem soll es möglich sein, Prozeduraufrufe rekursiv zu verfolgen.

vereinfachtes fiktives Log-Beispiel:

Code: Alles auswählen

Prozedur A gestartet
Prozedur B gestartet
Prozedur C gestartet
Prozedur D gestartet
Prozedur D beendet: Erfolgreich
Prozedur E gestartet
Prozedur E beendet: Erfolgreich
Prozedur C beendet: Erfolgreich
Prozedur B beendet: Fehler
Prozedur A beendet: Fehler
Prozedur X gestartet
Prozedur Y gestartet
Prozedur Y beendet: Erfolgreich
Prozedur X beendet: Erfolgreich

daraus könnte ich nun eine Baumansicht erstellen:

Code: Alles auswählen

Prozedur A: Fehler
     Prozedur B: Fehler
          Prozedur C: Erfolgreich
               Prozedur D: Erfolgreich
               Prozedur E: Erfolgreich

Prozedur X: Erfolgreich
     Prozedur Y: Erfolgreich

so kann man schön sehen, welche Prozeduren von einer Programmfunktion (hier z.B. 'Prozedur A' oder 'Prozedur X') aufgerufen werden.

....Problem bei dieser Methode ist, dass bei mehreren Threads die Verarbeitung durcheinander geraten wird. So könnte z.B. 'Prozedur A' in der Logausgabe mehrfach geöffnet oder geschlossen werden. Um das zu verhindern würde ich noch eine Art Thread-ID hinzufügen, damit immer eindeutig ist, welcher Thread gerade welche Log-Nachricht gesendet hat.

Ist das möglich eine Thread-ID oder irgend ein handle zu ermitteln, um eine Eindeutigkeit zu erreichen?

viele Grüße,
SBond

Beitrag von **RSBasic** » 22.09.2014 20:49

Ich weiß nicht, ob du sowas suchst, aber reicht dir die Speicheradresse (@Proc()) aus?
Bei Threads gibts ja auch ThreadID().

SBond · Beitrag von **SBond** » 22.09.2014 21:21

das schwierige daran ist, dass ich diese Information aus der laufenden Prozedur abgreifen wollte:

einfaches Beispiel:

Code: Alles auswählen

Enumeration
	#Gestartet
	#Beendet
EndEnumeration

Procedure LogMsg(Prozedurname.s, ThreadID.i, Status.i)
	
	Protected Statustext.s = ""
	
	Select Status
	Case #Gestartet: Statustext = "gestartet!"
	Case #Beendet: Statustext = "beendet!"
	EndSelect

	Debug  "Prozedurname: " + Prozedurname + "   Thread-ID: " + Str(ThreadID) + "   Nachricht: " + Statustext
	
EndProcedure


Procedure Funktion_C ()
	LogMsg(#PB_Compiler_Procedure, 0, #Gestartet)
;   ...irgendwas
	LogMsg(#PB_Compiler_Procedure, 0, #Beendet)
EndProcedure


Procedure Funktion_B ()
	LogMsg(#PB_Compiler_Procedure, 0, #Gestartet)
;   ...irgendwas
	Funktion_C ()
;   ...irgendwas
	LogMsg(#PB_Compiler_Procedure, 0, #Beendet)
EndProcedure


Procedure Funktion_A ()
	LogMsg(#PB_Compiler_Procedure, 0, #Gestartet)
;   ...irgendwas
	Funktion_B ()
;   ...irgendwas
	LogMsg(#PB_Compiler_Procedure, 0, #Beendet)
EndProcedure


Funktion_A ()

Der zweite Parameter in LogMsg(), der überall 0 ist, soll eine ID bekommen.
...es ist recht schwierig. Wenn ein Thread z.B. Funktion_A () startet, dann soll rekursiv für alle Prozeduren die gleiche 'Thread-ID' verwendet werden. Startet währendessen ein anderer Threat auch die Funktion_A (), soll muss dieser Thread eine andere 'Thread-ID' rekursiv verwenden.

ich könnte natürlich stumpf jede Prozedur um einen Parameter erweitern, in dem ich immer eine ID von der nennen wir es mal 'Parent-Prozedur' weiterreiche, aber das wäre nicht wirklich toll

Beitrag von **RSBasic** » 22.09.2014 21:30

SBond hat geschrieben:ich könnte natürlich stumpf jede Prozedur um einen Parameter erweitern, in dem ich immer eine ID von der nennen wir es mal 'Parent-Prozedur' weiterreiche, aber das wäre nicht wirklich toll

Du kannst die Parameterlistenänderung mit Hilfe eines Macros erledigen. Wenn du es nicht mehr benötigst, dann kommentierst du dein Macro einfach aus, ohne an vielen Stellen ändern zu müssen.

GPI · Beitrag von **GPI** » 22.09.2014 21:47

Also mit Windows gehts:
http://msdn.microsoft.com/en-us/library ... 85%29.aspx

Code: Alles auswählen

Procedure test()
  ;x=GetCurrentThread_()
  
  Debug "test von "+Hex(GetCurrentThreadId_())
EndProcedure

Procedure mythread(dummy)
  Debug "my Threadid:"+Hex(GetCurrentThreadId_())
  Delay(100+Random(200))
  test()
  Delay(1000)
EndProcedure

Debug "main:"
test()
Debug "--------"

For i=0 To 10
  a=CreateThread(@mythread(),0)
  Debug "newhtread (passt leider nicht):"+Hex(a)+", "+Hex(ThreadID(a))
  Delay(100)
  
Next
Delay(2000)
Debug "end"

SBond · Beitrag von **SBond** » 22.09.2014 21:53

ich denke, dass ist genau das richtige.

ich danke euch für eure Hilfe

Beitrag von **NicTheQuick** » 23.09.2014 00:29

Wenn man ohne API arbeiten will, kann man vielleicht etwas mit Threaded basteln.

Code: Alles auswählen

Global.i currentThreadId.i, currentThreadIdLock.i = CreateMutex()
Procedure.i getNewThreadId()
	Protected newId.i
	
	LockMutex(currentThreadIdLock)
	newId = currentThreadId
	currentThreadId + 1
	UnlockMutex(currentThreadIdLock)
	
	ProcedureReturn newId
EndProcedure


Threaded threadId.i
threadId = getNewThreadId()

Procedure a()
	Debug "Thread " + threadId + ": Begin " + #PB_Compiler_Procedure
	Delay(Random(100, 10))
	Debug "Thread " + threadId + ": End " + #PB_Compiler_Procedure
EndProcedure

Procedure thread(dummy.i)
	threadId = getNewThreadId()
	Debug "Thread " + threadId + " started."
	
	Delay(100)
	
	a()
	
	Debug "Thread " + threadId + " finished."
EndProcedure

Debug "Main thread has id " + threadId

CreateThread(@thread(), 0)
CreateThread(@thread(), 0)
CreateThread(@thread(), 0)
CreateThread(@thread(), 0)

Delay(3000)

helpy · Beitrag von **helpy** » 23.09.2014 10:36

Die Idee von NicTheQuick etwas erweitert:

Modul modDBG.pbi:

Code: Alles auswählen

DeclareModule DBG
  EnableExplicit
  
	Macro MSG(__msg__)
		CompilerIf #PB_Compiler_Module <> ""
			CompilerIf #PB_Compiler_Procedure <> ""
				DBG::DebugOut(#PB_Compiler_Module+"::"+#PB_Compiler_Procedure, __msg__)
			CompilerElse
				DBG::DebugOut(#PB_Compiler_Module+"::@GLOBAL", __msg__)
			CompilerEndIf
		CompilerElse
			CompilerIf #PB_Compiler_Procedure <> ""
				DBG::DebugOut(#PB_Compiler_Procedure, __msg__)
			CompilerElse
				DBG::DebugOut("@GLOBAL", __msg__)
			CompilerEndIf
		CompilerEndIf
	EndMacro
	
	Macro InitThread()
	  CompilerIf #PB_Compiler_Thread = #False
	    CompilerError "Compiler option 'Create threadsafe executeables' is not enabled!"
	  CompilerEndIf
		DBG::NewThread( #PB_Compiler_Module, #PB_Compiler_Procedure )
	EndMacro
	
	Declare DebugOut( Scope.s, Message.s )
	Declare NewThread( ModuleName.s, ProcedureName.s )
EndDeclareModule

Module DBG
	EnableExplicit
	
	Global   Thread_Count.i, Mutex.i
	Threaded Thread_ID.i
	Threaded Thread_Name.s
	
	Procedure DebugOut( Scope.s, Message.s )
	  If Thread_Name <> ""
	    Debug FormatDate( "%yyyy-%mm-%dd %hh:%ii:%ss", Date() ) + " Thread>>" + Thread_Name + " Scope>>" + Scope + " " + Message
	  Else
	    Debug FormatDate( "%yyyy-%mm-%dd %hh:%ii:%ss", Date() ) + " Scope>>" + Scope + " " + Message
	  EndIf
	EndProcedure
	
	Procedure NewThread( ModuleName.s, ProcedureName.s )
		If Not Mutex
			Mutex = CreateMutex()
		EndIf
		
		If Not Thread_ID
			LockMutex(Mutex)
			Thread_Count + 1
			Thread_ID = Thread_Count
			UnlockMutex(Mutex)
			
			If ModuleName <> ""
				Thread_Name + ModuleName + "::"
			EndIf
			
			If ProcedureName <> ""
				Thread_Name + ProcedureName
			Else
				Thread_Name + "@GLOBAL"
			EndIf
			
			Thread_Name + "-" + RSet( Str(Thread_ID), 5, "0" )
		EndIf
	EndProcedure
EndModule

Testprogramm:

Code: Alles auswählen

XIncludeFile "modDBG.pbi"
DBG::InitThread() ; main thread

Procedure ProcedureA()
  DBG::MSG( "begin" )
  Delay(Random(250, 10))
  DBG::MSG( "end" )
EndProcedure

Procedure ProcedureB()
  DBG::MSG( "begin" )
  Delay(Random(250, 10))
  DBG::MSG( "end" )
EndProcedure

Procedure Thread_A(dummy.i)
  DBG::InitThread()
  DBG::MSG( "started" )
  
  Delay(100)
  ProcedureA()
  
  Delay(100)
  ProcedureB()
  
  DBG::MSG( "finished" )
EndProcedure

Procedure Thread_B(dummy.i)
  DBG::InitThread()
  DBG::MSG( "started" )
  
  Delay(100)
  ProcedureA()
  
  Delay(100)
  ProcedureB()
  
  DBG::MSG( "finished" )
EndProcedure

DBG::MSG( "Start creating threads ..." )

CreateThread(@Thread_A(), 0)
CreateThread(@Thread_A(), 0)
CreateThread(@Thread_A(), 0)
CreateThread(@Thread_A(), 0)

CreateThread(@Thread_B(), 0)
CreateThread(@Thread_B(), 0)
CreateThread(@Thread_B(), 0)
CreateThread(@Thread_B(), 0)

DBG::MSG( "Finished creating threads ..." )

ProcedureA()
ProcedureB()


Delay(2000)

ProcedureA()
ProcedureB()

DBG::MSG( "Finished global test!" )

Debug ""
Debug ""

DeclareModule Application
  EnableExplicit
  DBG::MSG( "DeclareModule Application" )
  
  Declare Main()
  ;}
  
  DBG::MSG( "EndDeclareModule Application" )
EndDeclareModule
End Application::Main()

Module Application
  EnableExplicit
  DBG::MSG( "Module Application" )
  
  ;{ Private procedures
  Procedure ProcedureA()
    DBG::MSG( "begin" )
    Delay(Random(250, 10))
    DBG::MSG( "end" )
  EndProcedure
  
  Procedure ProcedureB()
    DBG::MSG( "begin" )
    Delay(Random(250, 10))
    DBG::MSG( "end" )
  EndProcedure
  
  Procedure Thread_A(dummy.i)
    DBG::InitThread()
    DBG::MSG( "started" )
    
    Delay(100)
    ProcedureA()
    
    Delay(100)
    ProcedureB()
    
    DBG::MSG( "finished" )
  EndProcedure
  
  Procedure Thread_B(dummy.i)
    DBG::InitThread()
    DBG::MSG( "started" )
    
    Delay(100)
    ProcedureA()
    
    Delay(100)
    ProcedureB()
    
    DBG::MSG( "finished" )
  EndProcedure
  ;}
  
  ;{ Public procedures
  Procedure Main()
    DBG::MSG( "Start creating threads inside module ..." )
    
    CreateThread(@Thread_A(), 0)
    CreateThread(@Thread_A(), 0)
    CreateThread(@Thread_A(), 0)
    CreateThread(@Thread_A(), 0)
    
    CreateThread(@Thread_B(), 0)
    CreateThread(@Thread_B(), 0)
    CreateThread(@Thread_B(), 0)
    CreateThread(@Thread_B(), 0)
    
    DBG::MSG( "Finished creating threads ..." )
    
    ProcedureA()
    ProcedureB()
    
    
    Delay(2000)
    
    ProcedureA()
    ProcedureB()
    
    DBG::MSG( "Finished test inside module!" )
  EndProcedure
  ;}
  
  DBG::MSG( "EndModule Application" )
EndModule

Ein erstes Ergebnis:

Code: Alles auswählen

2014-09-23 10:40:37 Thread>>@GLOBAL-00001 Scope>>@GLOBAL Start creating threads ...
2014-09-23 10:40:37 Thread>>Thread_A-00002 Scope>>Thread_A started
2014-09-23 10:40:37 Thread>>Thread_A-00003 Scope>>Thread_A started
2014-09-23 10:40:37 Thread>>Thread_A-00004 Scope>>Thread_A started
2014-09-23 10:40:37 Thread>>Thread_A-00005 Scope>>Thread_A started
2014-09-23 10:40:37 Thread>>Thread_B-00006 Scope>>Thread_B started
2014-09-23 10:40:37 Thread>>Thread_B-00007 Scope>>Thread_B started
2014-09-23 10:40:37 Thread>>Thread_B-00008 Scope>>Thread_B started
2014-09-23 10:40:37 Thread>>@GLOBAL-00001 Scope>>@GLOBAL Finished creating threads ...
2014-09-23 10:40:37 Thread>>@GLOBAL-00001 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_B-00009 Scope>>Thread_B started
2014-09-23 10:40:37 Thread>>@GLOBAL-00001 Scope>>ProcedureA end
2014-09-23 10:40:37 Thread>>@GLOBAL-00001 Scope>>ProcedureB begin
2014-09-23 10:40:37 Thread>>@GLOBAL-00001 Scope>>ProcedureB end
2014-09-23 10:40:37 Thread>>Thread_B-00008 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_A-00004 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_A-00003 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_B-00007 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_A-00005 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_A-00002 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_B-00006 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_B-00009 Scope>>ProcedureA begin
2014-09-23 10:40:37 Thread>>Thread_A-00005 Scope>>ProcedureA end
2014-09-23 10:40:37 Thread>>Thread_A-00003 Scope>>ProcedureA end
2014-09-23 10:40:37 Thread>>Thread_A-00004 Scope>>ProcedureA end
2014-09-23 10:40:38 Thread>>Thread_B-00009 Scope>>ProcedureA end
2014-09-23 10:40:38 Thread>>Thread_B-00006 Scope>>ProcedureA end
2014-09-23 10:40:38 Thread>>Thread_A-00005 Scope>>ProcedureB begin
2014-09-23 10:40:38 Thread>>Thread_B-00007 Scope>>ProcedureA end
2014-09-23 10:40:38 Thread>>Thread_A-00003 Scope>>ProcedureB begin
2014-09-23 10:40:38 Thread>>Thread_A-00004 Scope>>ProcedureB begin
2014-09-23 10:40:38 Thread>>Thread_A-00003 Scope>>ProcedureB end
2014-09-23 10:40:38 Thread>>Thread_A-00003 Scope>>Thread_A finished
2014-09-23 10:40:38 Thread>>Thread_A-00004 Scope>>ProcedureB end
2014-09-23 10:40:38 Thread>>Thread_A-00004 Scope>>Thread_A finished
2014-09-23 10:40:38 Thread>>Thread_B-00008 Scope>>ProcedureA end
2014-09-23 10:40:38 Thread>>Thread_A-00002 Scope>>ProcedureA end
2014-09-23 10:40:38 Thread>>Thread_B-00009 Scope>>ProcedureB begin
2014-09-23 10:40:38 Thread>>Thread_B-00006 Scope>>ProcedureB begin
2014-09-23 10:40:38 Thread>>Thread_B-00007 Scope>>ProcedureB begin
2014-09-23 10:40:38 Thread>>Thread_B-00009 Scope>>ProcedureB end
2014-09-23 10:40:38 Thread>>Thread_B-00009 Scope>>Thread_B finished
2014-09-23 10:40:38 Thread>>Thread_B-00007 Scope>>ProcedureB end
2014-09-23 10:40:38 Thread>>Thread_B-00007 Scope>>Thread_B finished
2014-09-23 10:40:38 Thread>>Thread_B-00008 Scope>>ProcedureB begin
2014-09-23 10:40:38 Thread>>Thread_A-00002 Scope>>ProcedureB begin
2014-09-23 10:40:38 Thread>>Thread_A-00005 Scope>>ProcedureB end
2014-09-23 10:40:38 Thread>>Thread_A-00005 Scope>>Thread_A finished
2014-09-23 10:40:38 Thread>>Thread_B-00006 Scope>>ProcedureB end
2014-09-23 10:40:38 Thread>>Thread_B-00006 Scope>>Thread_B finished
2014-09-23 10:40:38 Thread>>Thread_A-00002 Scope>>ProcedureB end
2014-09-23 10:40:38 Thread>>Thread_A-00002 Scope>>Thread_A finished
2014-09-23 10:40:38 Thread>>Thread_B-00008 Scope>>ProcedureB end
2014-09-23 10:40:38 Thread>>Thread_B-00008 Scope>>Thread_B finished
2014-09-23 10:40:39 Thread>>@GLOBAL-00001 Scope>>ProcedureA begin
2014-09-23 10:40:39 Thread>>@GLOBAL-00001 Scope>>ProcedureA end
2014-09-23 10:40:39 Thread>>@GLOBAL-00001 Scope>>ProcedureB begin
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>ProcedureB end
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>@GLOBAL Finished global test!


2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>Application::@GLOBAL DeclareModule Application
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>Application::@GLOBAL EndDeclareModule Application
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>Application::Main Start creating threads inside module ...
2014-09-23 10:40:40 Thread>>Application::Thread_A-00010 Scope>>Application::Thread_A started
2014-09-23 10:40:40 Thread>>Application::Thread_A-00011 Scope>>Application::Thread_A started
2014-09-23 10:40:40 Thread>>Application::Thread_A-00012 Scope>>Application::Thread_A started
2014-09-23 10:40:40 Thread>>Application::Thread_A-00013 Scope>>Application::Thread_A started
2014-09-23 10:40:40 Thread>>Application::Thread_B-00014 Scope>>Application::Thread_B started
2014-09-23 10:40:40 Thread>>Application::Thread_B-00015 Scope>>Application::Thread_B started
2014-09-23 10:40:40 Thread>>Application::Thread_B-00016 Scope>>Application::Thread_B started
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>Application::Main Finished creating threads ...
2014-09-23 10:40:40 Thread>>Application::Thread_B-00017 Scope>>Application::Thread_B started
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00012 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00011 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00010 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00013 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00014 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00015 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00017 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00016 Scope>>Application::ProcedureA begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00013 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>Application::Thread_A-00011 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00012 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>Application::Thread_A-00013 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00011 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00017 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>Application::Thread_B-00014 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>Application::Thread_A-00013 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_A-00013 Scope>>Application::Thread_A finished
2014-09-23 10:40:40 Thread>>Application::Thread_A-00010 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>Application::Thread_A-00012 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00015 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>@GLOBAL-00001 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_B-00016 Scope>>Application::ProcedureA end
2014-09-23 10:40:40 Thread>>Application::Thread_B-00017 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00011 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_A-00011 Scope>>Application::Thread_A finished
2014-09-23 10:40:40 Thread>>Application::Thread_B-00014 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_A-00010 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00017 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_B-00017 Scope>>Application::Thread_B finished
2014-09-23 10:40:40 Thread>>Application::Thread_B-00015 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00016 Scope>>Application::ProcedureB begin
2014-09-23 10:40:40 Thread>>Application::Thread_B-00015 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_B-00015 Scope>>Application::Thread_B finished
2014-09-23 10:40:40 Thread>>Application::Thread_B-00014 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_B-00014 Scope>>Application::Thread_B finished
2014-09-23 10:40:40 Thread>>Application::Thread_A-00012 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_A-00012 Scope>>Application::Thread_A finished
2014-09-23 10:40:40 Thread>>Application::Thread_A-00010 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_A-00010 Scope>>Application::Thread_A finished
2014-09-23 10:40:40 Thread>>Application::Thread_B-00016 Scope>>Application::ProcedureB end
2014-09-23 10:40:40 Thread>>Application::Thread_B-00016 Scope>>Application::Thread_B finished
2014-09-23 10:40:42 Thread>>@GLOBAL-00001 Scope>>Application::ProcedureA begin
2014-09-23 10:40:42 Thread>>@GLOBAL-00001 Scope>>Application::ProcedureA end
2014-09-23 10:40:42 Thread>>@GLOBAL-00001 Scope>>Application::ProcedureB begin
2014-09-23 10:40:42 Thread>>@GLOBAL-00001 Scope>>Application::ProcedureB end
2014-09-23 10:40:42 Thread>>@GLOBAL-00001 Scope>>Application::Main Finished test inside module!

SBond · Beitrag von **SBond** » 23.09.2014 20:50

vielen Dank für euren Nachtrag

Ich werde es mir morgen mal genauer anschauen, da ich heute nicht mal mehr in der Lage bin, zwei einstellige Zahlen zu addieren

viele Grüße
SBond

auser · Beitrag von **auser** » 24.09.2014 07:56

Würd auch je nach Fall eher eine threaded Variable oder Semaphore nehmen als die ThreadID. Das Problem mit diesen ThreadIDs ist halt daß sie nur so lange eindeutig sind so lange der Thread läuft und danach die selbe ID von 'nem neuen Thread wiederverwendet werden kann. Das kann sowohl beim Prüfen ob der Thread noch läuft als auch beim Logging oder Debuggen zu Missverständnissen führen.

PureBoard

ermitteln, welcher Thread auf Prozedur zugreift

ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift

Re: ermitteln, welcher Thread auf Prozedur zugreift