5 files changed, 133 insertions, 0 deletions
diff --git a/ws2015/oss/blaetter/12/Prozess.java b/ws2015/oss/blaetter/12/Prozess.java
new file mode 100644
index 0000000..ae20a6c
--- /dev/null
+++ b/ws2015/oss/blaetter/12/Prozess.java
@@ -0,0 +1,31 @@
+public class Prozess extends Thread {
+    private Speicher my_speicher;
+    private int prozess_id;
+    public Prozess(int prozess_id, Speicher my_speicher) {
+        this.prozess_id = prozess_id;
+        this.my_speicher = my_speicher;
+    }
+    public void run() {
+        System.out.println("prozess " + prozess_id + " is now running");
+        while (true) {
+            if (Math.random() >= 0.5) {
+                // Hole Leserecht
+                my_speicher.leserecht_holen(prozess_id);
+                // lese
+                System.out.println("Prozess " + prozess_id + " hat gelesen: "
+                                   + my_speicher.lese());
+                // Leserecht freigeben
+                my_speicher.leserecht_freigeben(prozess_id);
+            } else {
+                // Arbeite als Schreiber
+                my_speicher.schreibrecht_holen(prozess_id);
+                // schreibe
+                my_speicher.schreibe(Integer.toString(prozess_id));
+                // schreiben
+                my_speicher.schreibrecht_freigeben(prozess_id);
+            }
+        }
+    }
+}
diff --git a/ws2015/oss/blaetter/12/Speicher.java b/ws2015/oss/blaetter/12/Speicher.java
new file mode 100644
index 0000000..b521466
--- /dev/null
+++ b/ws2015/oss/blaetter/12/Speicher.java
@@ -0,0 +1,75 @@
+public class Speicher {
+    private int anzahl_schreibewuensche; // Alter variablenname 'anzahl_der_schreibewunsche' war inkonsistent mit den anderen
+    private int anzahl_leser;
+    private boolean schreiber_aktiv;
+    private String daten;
+        
+    public Speicher (String initial) {
+        anzahl_schreibewuensche = 0;
+        anzahl_leser = 0;
+        schreiber_aktiv = false;
+        daten = initial;
+    }
+    public synchronized void leserecht_holen(int prozess_id) { // Alte methodennamen 'leserechte_holen' und 'leserechte_freigeben' waren inkonsistent
+        while ( schreiber_aktiv || anzahl_schreibewuensche > 0) { // Blocken bis kein Prozess schreibrecht hat oder will
+            try {
+                this.wait();
+            } catch (InterruptedException ie) {}
+        }
+                
+        anzahl_leser++;
+                
+        System.out.println("Prozess " + prozess_id
+                           + " ==> Leserecht erhalten (" + anzahl_leser + " Leser)");
+    }
+    public synchronized void leserecht_freigeben(int prozess_id) {
+        anzahl_leser--;
+        System.out.println("Prozess " + prozess_id
+                           + " ==> Leserecht freigegeben (" + anzahl_leser + " Leser)");
+        this.notifyAll(); // Alle blockenden Prozesse aufwecken (nacheinander)
+    }
+    public synchronized void schreibrecht_holen(int prozess_id) {
+        anzahl_schreibewuensche++;
+        while (schreiber_aktiv || anzahl_leser > 0) { // Blocken bis alle leser/schreiber fertig
+            try {
+                this.wait();
+            } catch (InterruptedException ie) {}
+        }
+        // Anfang kritischer Bereich
+        schreiber_aktiv = true;
+        anzahl_schreibewuensche--;
+        // Ende kritischer Bereich
+        System.out.println("Prozess " + prozess_id
+                           + " ==> Schreibrecht erhalten (" + anzahl_leser + " Leser)");
+    }
+    public synchronized void schreibrecht_freigeben(int prozess_id) {
+        schreiber_aktiv = false;
+        System.out.println("Prozess " + prozess_id
+                           + " ==> Schreibrecht freigegeben (" + anzahl_leser + " Leser)");
+        this.notifyAll();
+    }
+    public String lese() {
+        try { // Das Lesen dauert etwas...
+            Thread.sleep(400);
+        } catch (InterruptedException e) {}
+        return daten;
+    }
+    public synchronized void schreibe(String s) {
+        try { // Das Schreiben dauert etwas...
+            Thread.sleep(400);
+        } catch (InterruptedException e) {}
+        this.daten = s;
+    }
+}
diff --git a/ws2015/oss/blaetter/12/Vaterprozess.java b/ws2015/oss/blaetter/12/Vaterprozess.java
new file mode 100644
index 0000000..e063ae6
--- /dev/null
+++ b/ws2015/oss/blaetter/12/Vaterprozess.java
@@ -0,0 +1,17 @@
+public class Vaterprozess {
+    private Speicher my_speicher;
+    private Prozess[] prozesse;
+    public Vaterprozess() {
+        my_speicher = new Speicher("");
+        prozesse = new Prozess[5];
+        for (int i = 0; i < prozesse.length; i++) {
+            prozesse[i] = new Prozess(i, my_speicher);
+            prozesse[i].start();
+        }
+    }
+    public static void main(String[] args) {
+        new Vaterprozess();
+    }
+}
diff --git a/ws2015/oss/blaetter/12/abgabe.md b/ws2015/oss/blaetter/12/abgabe.md
new file mode 100644
index 0000000..a6c4c29
--- /dev/null
+++ b/ws2015/oss/blaetter/12/abgabe.md
@@ -0,0 +1,6 @@
+# Synchronisation von Threads in Java
+a)  Eine Menge an Prozesszuständen, die nicht gleichzeitig eingenommen werden sollen -- z.B. Zugriff auf das selbe gemeinsames Betriebsmittel durch mehr als einen Prozess
+e)  In `schreibe()` wird Zugriff durch nur einen Prozess durch die Semantik von `schreibrecht_holen()` und `schreibrecht_freigeben()` gesichert (und die Annahme, dass die genannten Methoden nur in einer sinnvollen Reihenfolge aufgerufen werden)
+  
+    Da die Methode `schreibrecht_holen()` als `synchronized` deklariert ist stellt die Java-Runtime sicher, dass zu jedem Zeitpunkt maximal ein Prozess den in der Methode markierten Bereich ausführt.
diff --git a/ws2015/oss/blaetter/12/manifest b/ws2015/oss/blaetter/12/manifest
new file mode 100644
index 0000000..fa11a09
--- /dev/null
+++ b/ws2015/oss/blaetter/12/manifest
@@ -0,0 +1,4 @@
+Prozess.java
+Speicher.java
+Vaterprozess.java
+abgabe.pdf
+\ No newline at end of file

diff --git a/ws2015/oss/blaetter/12/Prozess.java b/ws2015/oss/blaetter/12/Prozess.java new file mode 100644 index 0000000..ae20a6c --- /dev/null +++ b/ws2015/oss/blaetter/12/Prozess.java
@@ -0,0 +1,31 @@
	1	public class Prozess extends Thread {
	2	private Speicher my_speicher;
	3	private int prozess_id;
	4
	5	public Prozess(int prozess_id, Speicher my_speicher) {
	6	this.prozess_id = prozess_id;
	7	this.my_speicher = my_speicher;
	8	}
	9
	10	public void run() {
	11	System.out.println("prozess " + prozess_id + " is now running");
	12	while (true) {
	13	if (Math.random() >= 0.5) {
	14	// Hole Leserecht
	15	my_speicher.leserecht_holen(prozess_id);
	16	// lese
	17	System.out.println("Prozess " + prozess_id + " hat gelesen: "
	18	+ my_speicher.lese());
	19	// Leserecht freigeben
	20	my_speicher.leserecht_freigeben(prozess_id);
	21	} else {
	22	// Arbeite als Schreiber
	23	my_speicher.schreibrecht_holen(prozess_id);
	24	// schreibe
	25	my_speicher.schreibe(Integer.toString(prozess_id));
	26	// schreiben
	27	my_speicher.schreibrecht_freigeben(prozess_id);
	28	}
	29	}
	30	}
	31	}


diff --git a/ws2015/oss/blaetter/12/Speicher.java b/ws2015/oss/blaetter/12/Speicher.java new file mode 100644 index 0000000..b521466 --- /dev/null +++ b/ws2015/oss/blaetter/12/Speicher.java
@@ -0,0 +1,75 @@
	1	public class Speicher {
	2	private int anzahl_schreibewuensche; // Alter variablenname 'anzahl_der_schreibewunsche' war inkonsistent mit den anderen
	3	private int anzahl_leser;
	4	private boolean schreiber_aktiv;
	5	private String daten;
	6
	7	public Speicher (String initial) {
	8	anzahl_schreibewuensche = 0;
	9	anzahl_leser = 0;
	10	schreiber_aktiv = false;
	11	daten = initial;
	12	}
	13
	14	public synchronized void leserecht_holen(int prozess_id) { // Alte methodennamen 'leserechte_holen' und 'leserechte_freigeben' waren inkonsistent
	15	while ( schreiber_aktiv \|\| anzahl_schreibewuensche > 0) { // Blocken bis kein Prozess schreibrecht hat oder will
	16	try {
	17	this.wait();
	18	} catch (InterruptedException ie) {}
	19	}
	20
	21	anzahl_leser++;
	22
	23	System.out.println("Prozess " + prozess_id
	24	+ " ==> Leserecht erhalten (" + anzahl_leser + " Leser)");
	25	}
	26
	27	public synchronized void leserecht_freigeben(int prozess_id) {
	28	anzahl_leser--;
	29	System.out.println("Prozess " + prozess_id
	30	+ " ==> Leserecht freigegeben (" + anzahl_leser + " Leser)");
	31	this.notifyAll(); // Alle blockenden Prozesse aufwecken (nacheinander)
	32	}
	33
	34	public synchronized void schreibrecht_holen(int prozess_id) {
	35	anzahl_schreibewuensche++;
	36
	37	while (schreiber_aktiv \|\| anzahl_leser > 0) { // Blocken bis alle leser/schreiber fertig
	38	try {
	39	this.wait();
	40	} catch (InterruptedException ie) {}
	41	}
	42
	43	// Anfang kritischer Bereich
	44
	45	schreiber_aktiv = true;
	46	anzahl_schreibewuensche--;
	47
	48	// Ende kritischer Bereich
	49
	50	System.out.println("Prozess " + prozess_id
	51	+ " ==> Schreibrecht erhalten (" + anzahl_leser + " Leser)");
	52	}
	53
	54	public synchronized void schreibrecht_freigeben(int prozess_id) {
	55	schreiber_aktiv = false;
	56	System.out.println("Prozess " + prozess_id
	57	+ " ==> Schreibrecht freigegeben (" + anzahl_leser + " Leser)");
	58	this.notifyAll();
	59	}
	60
	61	public String lese() {
	62	try { // Das Lesen dauert etwas...
	63	Thread.sleep(400);
	64	} catch (InterruptedException e) {}
	65	return daten;
	66	}
	67
	68	public synchronized void schreibe(String s) {
	69	try { // Das Schreiben dauert etwas...
	70	Thread.sleep(400);
	71	} catch (InterruptedException e) {}
	72	this.daten = s;
	73	}
	74
	75	}


diff --git a/ws2015/oss/blaetter/12/Vaterprozess.java b/ws2015/oss/blaetter/12/Vaterprozess.java new file mode 100644 index 0000000..e063ae6 --- /dev/null +++ b/ws2015/oss/blaetter/12/Vaterprozess.java
@@ -0,0 +1,17 @@
	1	public class Vaterprozess {
	2	private Speicher my_speicher;
	3	private Prozess[] prozesse;
	4
	5	public Vaterprozess() {
	6	my_speicher = new Speicher("");
	7	prozesse = new Prozess[5];
	8	for (int i = 0; i < prozesse.length; i++) {
	9	prozesse[i] = new Prozess(i, my_speicher);
	10	prozesse[i].start();
	11	}
	12	}
	13
	14	public static void main(String[] args) {
	15	new Vaterprozess();
	16	}
	17	}


diff --git a/ws2015/oss/blaetter/12/abgabe.md b/ws2015/oss/blaetter/12/abgabe.md new file mode 100644 index 0000000..a6c4c29 --- /dev/null +++ b/ws2015/oss/blaetter/12/abgabe.md
@@ -0,0 +1,6 @@
	1	# Synchronisation von Threads in Java
	2
	3	a) Eine Menge an Prozesszuständen, die nicht gleichzeitig eingenommen werden sollen -- z.B. Zugriff auf das selbe gemeinsames Betriebsmittel durch mehr als einen Prozess
	4	e) In `schreibe()` wird Zugriff durch nur einen Prozess durch die Semantik von `schreibrecht_holen()` und `schreibrecht_freigeben()` gesichert (und die Annahme, dass die genannten Methoden nur in einer sinnvollen Reihenfolge aufgerufen werden)
	5
	6	Da die Methode `schreibrecht_holen()` als `synchronized` deklariert ist stellt die Java-Runtime sicher, dass zu jedem Zeitpunkt maximal ein Prozess den in der Methode markierten Bereich ausführt.


diff --git a/ws2015/oss/blaetter/12/manifest b/ws2015/oss/blaetter/12/manifest new file mode 100644 index 0000000..fa11a09 --- /dev/null +++ b/ws2015/oss/blaetter/12/manifest
@@ -0,0 +1,4 @@
	1	Prozess.java
	2	Speicher.java
	3	Vaterprozess.java
	4	abgabe.pdf \ No newline at end of file