Austausch von Daten? < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 16:25 Di 15.11.2011 | | Autor: | bandchef |
| Aufgabe | | Erstellen sie ein Programm in dem 2 Prozesse erzeugt werden und überprüfen Sie ob zwischen den Prozessen der Austausch von Daten über globale Variable möglich ist. |
Hi Leute!
Hier ist mein Programm:
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int austausch = 0;
int main()
{
[mm] pid_t [/mm] pid;
pid = fork();
return 0;
}
Wie kann ich nun nachprüfen ob Datenaustausch machbar ist? Dafür hab ich die globale Variable austausch angelegt. Wie muss ich nun aber weiter machen? Irgendwie muss ich ja auf den Vater- bzw. Kindprozess zugreifen können. Wie macht man das?
|
|
| |
|
Hallo!
Im Prinzip machst du nun eine Abfrage, ob pid==0 ist (Dann ist es der Kind-Prozess) oder nicht (dann ist es der Vaterprozess)
Im Prinzip ne einfache If-Else-Konstruktion.
Der eine Prozess könnte die Variable hochzählen, und ausgeben, auf welchen Wert er sie gesetzt hat. Der andere Prozess könnte genauso lange nur die Variable ausgeben.
Damit das nicht zu schnell geht, könntest du hier und da ein sleep(1) verwenden, um ne Sekunde Wartezeit einzufügen.
Wenn die Prozesse kommunizieren können, würdest du auch beim Kind-Prozess sehen, wie die Variable größer wird.
Was erwartest du denn für ein Ergebnis?
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 17:15 Do 17.11.2011 | | Autor: | bandchef |
Verstehe ich das so richtig:
Wenn ich nun mein Programm so erweitere,
| 1: |
| | 2: | #include<stdio.h>
| | 3: | #include<stdlib.h>
| | 4: | #include<unistd.h>
| | 5: |
| | 6: | int austausch = 0;
| | 7: |
| | 8: | int main()
| | 9: | {
| | 10: | $ pid_t $ pid;
| | 11: | pid = fork();
| | 12: |
| | 13: | if(pid == 0)
| | 14: | {
| | 15: | printf("Kindprozess");
| | 16: | int ergebnisKind;
| | 17: | ergebnisKind = 1+1;
| | 18: | }
| | 19: | else
| | 20: | {
| | 21: | printf("Vaterprozess");
| | 22: | int ergebnisVater;
| | 23: | ergebnisVater = 2+2;
| | 24: | }
| | 25: |
| | 26: | return 0;
| | 27: | }
|
dann kann ich mit dem if eine Aufgabe dem Kindprozess zuweisen und eine weitere Aufgabe dem Vaterprozess? Stimmt das soweit? Nun gibt mir der Kindprozess das Wort Kindprozess aus und berechnet ergebnisKind = 2. Der Vaterprozess gibt das wort Vaterprozess aus und berechnet ergebnisVater = 4.
Nun um zu meiner Frage zurückzukehren:
Kann ich nun Datenaustausch mit der globalen Variable "austausch" programmieren, oder ist das nicht möglich? Hier ein kleines Beispiel wie ich mir denn Datenaustausch zwischen Kind- und Vaterprozess vorstelle:
| 1: |
| | 2: | #include<stdio.h>
| | 3: | #include<stdlib.h>
| | 4: | #include<unistd.h>
| | 5: |
| | 6: | int austausch = 0;
| | 7: |
| | 8: | int main()
| | 9: | {
| | 10: | $ pid_t $ pid;
| | 11: | pid = fork();
| | 12: |
| | 13: | if(pid == 0)
| | 14: | {
| | 15: | printf("Kindprozess");
| | 16: | int ergebnisKind;
| | 17: | ergebnisKind = 1+1;
| | 18: | austausch = ergebnisKind;
| | 19: | }
| | 20: | else
| | 21: | {
| | 22: | printf("Vaterprozess");
| | 23: | int ergebnisVater;
| | 24: | ergebnisVater = austausch;
| | 25: | ergebnisVater = ergebnisVater+2;
| | 26: | }
| | 27: |
| | 28: | return 0;
| | 29: | }
|
Geht das so?
|
|
|
| |
|
Hallo!
Zunächst:
Ja, du hast es erefasst. Mit dem IF/ELSE weist du dem Vater- und Kindprozess unterschiedlichen Code zum Abarbeiten zu.
Allerdings solltest du dir überlegen, wie du das geschickt anstellst. Ich habe oben ja bereits gesagt:
-> Der Vaterprozess sollte deine globale Variable in einer Schleife hochzählen.
-> Der Kind-Prozess sollte nur zuhören, d.h. ebenfalls in einer schleife immer wieder den Inhalt der Variablen ausgeben.
Wenn die Kommunikation klappt, solltest du sehen, wie der Kind-Prozess immer größere Zahlen ausgibt, obwohl er selbst die Zahl ja nicht vergrößert.
Und wie gesagt, benutze sleep(1), um das ganze langsamer ablaufen zu lassen.
|
|
|
|
