Aufgabenblatt 5 Musterlösung

Transkript

1 Prof. Dr. rer. nat. Roland Wismüller Aufgabenblatt 5 Musterlösung Vorlesung Betriebssysteme I Wintersemester 2017/18 Aufgabe 1: Implementierung von Threads (Bearbeitung zu Hause) Der größte Vorteil ist die Effizienz. Es werden keine Einsprünge in den Betriebssystem-Kern benötigt, um eine Threadwechsel vorzunehmen. Der größte Nachteil ist, daß der ganze Prozeß blockiert, sobald einer der Threads blockiert. Aufgabe 2: Dateiverwaltung (Bearbeitung in der Übungsstunde) #include <fcntl.h> // for open() #include <unistd.h> // for lseek(), write(), close() #include <stdlib.h> // for exit() #include <stdio.h> // for perror() int main() int fd; char buffer[] = "Hallo"; // Datei erzeugen und zum Schreiben öffnen // Rechte 0644 = rw-r--r-- if ((fd = open("/tmp/datei.txt", O_CREAT O_WRONLY, 0644)) < 0) perror("cannot open file"); // Auf Byte 20 positionieren if (lseek(fd, 20, SEEK_SET) < 0) perror("cannot seek"); // 5 Zeichen aus Puffer schreiben if (write(fd, buffer, 5) < 0) perror("cannot write"); // Datei schließen close(fd); Die Datei ist 25 Bytes groß. Durch das Schreiben ab Byte 20 werden die ersten 20 Bytes mit Nullen aufgefüllt. Aufgabe 3: Vater-Kind Prozesse in Unix (Bearbeitung in der Übungsstunde) /***************************************************************************** FILE: parent-child.c Author: AK 1

2 Bei dem Ablauf des Programms kann nicht vorhergesehen werden, in welcher Reihenfolge die Meldungen der Prozesse auf dem Bildschirm erscheinen (race condition). COMPILE (& link) with: gcc -o parent-child parent-child.c ******************************************************************************/ #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <unistd.h> #define MAX // fuer printf, perror // fuer exit // Konstante int main( void) pid_t retpid; int i, j; retpid = fork(); // Kindprozess erzeugen // Bei Erfolg wird dem Vater-Prozess die PID des Kindes zurückgegeben // und 0 dem Kind-Prozess. Bei Fehlern wird dem Vaterprozess -1 // zurückgegeben. if (retpid < 0) perror("error in fork\n"); if (retpid == 0) // Kind-Prozess for ( i=1; i<20; i++) // Last erzeugen: eine Schleife, die nur Zeit verbraucht for (j=0; j<max; j++); // Buchstabe c ausgeben und stdout-puffer leeren putchar( c ); fflush(stdout); exit(0); else // Vater-Prozess for (i=1; i<20; i++) for (j=0; j<max; j++); // Last erzeugen // Buchstabe a ausgeben und stdout-puffer leeren putchar( a ); fflush(stdout); int status; wait(&status); printf("\nchild State: %ld=0x%lx\n", status, status); Programm ausführen: bslab01%./parent-child 2

3 aacacaacacacacaaccacacacacccaaaaaccccc Child State: 0=0x0 Bei dem Ablauf des Programms kann nicht vorhergesehen werden, in welcher Reihenfolge die Meldungen der Prozesse auf dem Bildschirm erscheinen (race condition). Aufgabe 4: POSIX Threads (Bearbeitung in der Übungsstunde) #include <unistd.h> // for sleep #include <stdio.h> // for printf #include <stdlib.h> // for exit() #include <pthread.h> // POSIX threads #include <string.h> // string functions: strcpy void * print_message(void *ptr); // prototype for thread routine typedef struct _threaddata // data to be passed to a thread int thread_id; char message[100]; threaddata; int main() pthread_t thread1, thread2; // thread variables threaddata data1, data2; // own structs to be passed to the threads // set data to pass to first thread data1.thread_id = 1; strcpy(data1.message, "Hello!"); // set data to pass to second thread data2.thread_id = 2; strcpy(data2.message, "Hi!"); // create both threads if ( (pthread_create(&thread1, NULL, print_message, (void *) &data1)!= 0) (pthread_create(&thread2, NULL, print_message, (void *) &data2)!= 0)) printf("thread creation failed\n"); printf("main thread\n"); /* */ Main thread now waits for both threads to terminate, before it exits. If main thread exits, both threads exit, even they have not finished their work (check this by by removing the pthread_join calls.) pthread_join(thread1, NULL); pthread_join(thread2, NULL); exit(0); /* * print_message is used as the start routine for the threads used * Params: ptr - pointer to the thread s data 3

4 */ void *print_message(void *ptr) threaddata *data; data = (threaddata *) ptr; // cast to a pointer to threaddata // do some job: display a message int i; for (i=1; i<20; i++) printf("thread %d says %s \n", data->thread_id, data->message); sleep(data->thread_id); // sleep for a while... return NULL; Aufgabe 5: Java Threads (Bearbeitung in der Übungsstunde) a) // The thread class for printing a specified character public class DisplayChar implements Runnable private char chartodisplay; // The character to print private int times; // The times to repeat // Construct a thread with specified character and number of // times to print the character public DisplayChar(char c, int t) chartodisplay = c; times = t; // Implement the run() method public void run() for (int i = 0; i < times; i++) // Zum Ausprobieren: Threads schlafen legen // Versuchen Sie auch Thread.yield() statt sleep(). if (i == 50) System.out.print(Character.toUpperCase(charToDisplay)); try Thread.sleep(100); catch (InterruptedException e) else System.out.print(charToDisplay); // Wichtig, damit Ausgaben sofort erscheinen System.out.flush(); public static void main(string[] args) Thread ta = new Thread(new DisplayChar( a, 100)); Thread tb = new Thread(new DisplayChar( b, 100)); Thread tc = new Thread(new DisplayChar( c, 100)); Thread td = new Thread(new DisplayChar( d, 100)); 4

5 // Start threads ta.start(); tb.start(); tc.start(); td.start(); Aufgabe 6: Threads mit gemeinsamen Variablen (Bearbeitung in der Übungsstunde) // Diese Klasse enthält eine Integer Variable, die von allen // Threads genutzt werden kann. class CommonVar public int i; public CommonVar() i = 0; // Thread-Klasse public class Test extends Thread private CommonVar cvar; // Konstruktor initialisiert Referenz auf gemeinsame Variable public Test(CommonVar c) cvar = c; // Implementierung der run() Methode public void run() for (int i = 0; i < ; i++) cvar.i++; public static void main(string[] args) throws InterruptedException CommonVar c = new CommonVar(); Thread t1 = new Test(c); Thread t2 = new Test(c); // Starte Threads t1.start(); t2.start(); // Warte auf Thread-Ende t1.join(); t2.join(); // Drucke c.i System.out.println(c.i); 5

6 Programm ausführen: bslab01% java Test bslab01% java Test bslab01% java Test Der Prozessor führt das Hochzählen in drei Schritten durch: erst wird der alte Wert aus dem Speicher geladen, dann wird er hochgezählt, dann wieder in den Speicher geschrieben. Es kann daher vorkommen, daß zwei Threads (fast) gleichzeitig den alten Wert holen (also bevor der andere Thread ihn wieder speichern konnte). Dann geht mindestens eine Änderung (also eine Inkrementierung) verloren, so daß das Ergebnis kleiner als wird. 6