Die Funktionalität „Multiple Conversations“ ermöglicht einem CPI-C-Client, innerhalb eines Programmlaufs gleichzeitig mehrere Conversations zu unterhalten. Die Conversations können zu verschiedenen UTM-Anwendungen oder zu derselben UTM-Anwendung aufgebaut werden.
Das Trägersystem UPIC unterstützt „Multiple Conversations“ nur auf Systemen, die Multithreading unterstützen (Unix-, Linux- und Windows-Systeme). Siehe dazu „„Multithreading“.
Multithreading bedeutet, dass innerhalb des Prozesses, in dem ein Programm abläuft, mehrere Threads gestartet werden können. Unter Threads versteht man parallel laufende Programmteile innerhalb eines Prozesses, in denen Verarbeitungsschritte unabhängig voneinander bearbeitet werden können. Threads werden deshalb auch oft nebenläufige Prozesse genannt. Der Einsatz von Threads entspricht quasi einem Multi-Processing, das vom Programm selbst verwaltet wird und im selben Prozess abläuft wie das Programm selbst.
CPI-C-Clients, die auf Systemen mit Multithreading ablaufen und entsprechend implementiert sind, können also zu einem Zeitpunkt mit mehreren UTM-Services gekoppelt werden.
CPI-C-Clients, die auf Systemen ablaufen, die kein Multithreading unterstützen, können zu einem Zeitpunkt nur eine Conversation unterhalten. Erst wenn diese Conversation abgebaut ist, kann eine neue aufgebaut werden.
Wenn eine Client-Anwendung gleichzeitig mehrere Conversations bearbeiten will, dann muss jede einzelne dieser Conversations in einem eigenen Thread unabhängig von den anderen Conversations bearbeitet werden. Dabei müssen Sie folgendes beachten:
Der erste Thread des Prozesses, in dem die anderen Threads gestartet werden, ist der Main-Thread. Im Main-Thread kann - wie in jedem anderen Prozess - auch eine Conversation aufgebaut werden.
Für jede weitere Conversation, die das Programm aufbauen und parallel bearbeiten soll, muss explizit ein Thread gestartet werden. Zum Starten der Threads stehen Systemaufrufe zur Verfügung. Diese Systemaufrufe sind abhängig vom Betriebssystem und vom verwendeten Compiler (siehe Beispiel auf "Multiple Conversations (Unix-, Linux- und Windows- Systeme)").
In jedem der gestarteten Threads muss die Ablaufumgebung für den CPI-C-Client gestartet werden. Dazu muss in jedem Thread ein Enable_UTM_UPIC-Aufruf abgesetzt werden. Dabei kann sich das CPI-C-Programm in allen Threads mit demselben oder auch mit verschiedenen Namen anmelden.
In jedem einzelnen Thread müssen die Conversation Characteristics mit einem
Initialize_Conversation-Aufruf gesetzt werden. Dabei wird der Conversation von UPIC eine eigene Conversation-ID zugeordnet.
Jede Conversation-ID kann nur innerhalb des Threads benutzt werden, in dem die zugehörige Conversation initialisiert und aufgebaut wurde. Wird die Conversation-ID in einem anderen Thread bei einem CPI-C-Aufruf angegeben, dann liefert UPIC den Returncode CM_PROGRAM_PARAMETER_CHECK zurück.
In jedem Thread muss sich das Programm mit Disable_UTM_UPIC bei UPIC abmelden, bevor der Thread beendet wird.
Der Main-Thread darf sich erst beenden, wenn alle anderen Threads abgemeldet und beendet sind.
Die Abläufe innerhalb des Client-Programms sind im folgenden Bild dargestellt.
Bild 15: Starten mehrerer Threads innerhalb eines Prozesses (Unix-, Linux- und Windows-Systeme)(die grau unterlegte Fläche entspricht dem Prozess, in dem das Client-Programm abläuft)
void main () 1.
{
...
thrd[0] = CreateThread(...,UpicThread,...); 2.
thrd[1] = CreateThread(...,UpicThread,...);
...
Enable_UTM_UPIC (...); 3.
...
/* Aufrufe zum Aufbauen und Bearbeiten einer Conversation im */
/* Main-Thread: */
Initialize_Conversation (...)
...
Allocate (...)
....
Send_Data (...)
...
Receive (...)
...
Disable_UTM_UPIC (...);
...
WaitforMultipleObjects(2,&thrd[0],...); 4.
ExitProcess (0); 5.
}
DWORD WINAPI UpicThread(LPVOID arg) 6.
{
...
Enable_UTM_UPIC (...);
...
/* Aufrufe zum Aufbauen und Bearbeiten der Conversation im Thread*/
/* wie im Main-Thread unter 3. */
...
Disable_UTM_UPIC (...);
...
ExitThread(0); 7.
}
Prozess und Main-Thread werden gestartet.
Starten zweier weiterer Threads über den entsprechenden Systemaufruf. Der Systemaufruf ist abhängig vom System und vom verwendeten Compiler.
Jeder Thread wird mit der Funktion UpicThread() gestartet. In UpicThread() wird eine Conversation aufgebaut und bearbeitet (siehe 6). UpicThread ist ein frei wählbarer Name.Jeder Thread muss explizit einen Enable_UTM_UPIC- und einen Disable_UTM_UPIC-Aufruf ausführen. An dieser Stelle meldet sich der Main-Thread bei UPIC an. Nach dem Enable_UTM_UPIC-Aufruf können dann die CPI-C-Aufrufe für den Aufbau einer Conversation im Main-Thread und zum Bearbeiten dieser Conversation abgesetzt werden. Es können mehrere Conversations nacheinander im Main-Thread bearbeitet werden. Nach Beendigung der Conversation im Main-Thread muss sich dieser mit Disable_UTM_UPIC abmelden.
Der Main-Thread wartet, bis sich die beiden von ihm gestarteten Threads beenden.
Ende des Prozesses und des Main-Threads.
UpicThread() ist die Funktion, die aufgerufen wird, wenn ein neuer Thread gestartet wird. In ihr meldet sich der jeweilige Thread mit Enable_UTM_UPIC bei UPIC an und bearbeitet „seine Conversation“ (mit Initialize_Conversation, Set_..., Send_Data, Receive ...). Auch hier können mehrere Conversations nacheinander bearbeitet werden. Nach Beenden der letzten Conversation meldet sich der Thread mit Disable_UTM_UPIC ab.
UpicThread() muss so programmiert werden, dass sich die nebeneinander laufenden Threads nicht gegenseitig beeinträchtigen. Der Code muss also so gestaltet werden, dass er gleichzeitig von mehreren Threads ausgeführt werden kann, d.h. die verwendeten Funktionen dürfen sich nicht gegenseitig den Kontext zerstören.
Ende des Threads.
Mit openUTM-Client wird die Source für ein Beispielprogramm zu „Multiple Conversations” ausgeliefert (siehe Abschnitt „Programmbeispiele für Windows-Systeme“).