Informatik 12/13 (G9)

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
parallelism:monitor:start

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
parallelism:monitor:start [2025/01/02 20:54] – [Aufgabe 4 (für Interessierte!)] Martin Pabstparallelism:monitor:start [2025/03/09 11:42] (aktuell) – [Aufgabe 2] Martin Pabst
Zeile 26: Zeile 26:
  
 Counter counter = new Counter(); Counter counter = new Counter();
 +ArrayList<Thread> threads = new ArrayList<>();
  
 for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
Zeile 31: Zeile 32:
    Thread t = new Thread(inc);    Thread t = new Thread(inc);
    t.setName("Thread " + i);    t.setName("Thread " + i);
 +   threads.add(t);
    t.start();    t.start();
 } }
 +
 +for (var t : threads) {
 +   t.join();
 +}
 +
 +println("Der Counter steht jetzt auf: ");
 +print(counter.counter, Color.lightcoral);
 +
  
 class Counter { class Counter {
Zeile 58: Zeile 68:
       for (long i = 1; i <= increment; i++) {       for (long i = 1; i <= increment; i++) {
          counter.increment();          counter.increment();
-         if(i % (increment/10) == 0) println(Thread.currentThread().getName() + " hat " + i + " mal erhöht!");+         if(i % (increment / 10) == 0) println(Thread.currentThread().getName() + " hat " + i + " mal erhöht!");
       }       }
-      println(Thread.currentThread().getName() + "\nDone! Counter steht auf: " + counter.counter, Color.lightblue);+      println(Thread.currentThread().getName() + " done!");
    }    }
  
Zeile 93: Zeile 103:
  
 <script type="text/plain" title="ThreadTest1.java"> <script type="text/plain" title="ThreadTest1.java">
- 
 Counter counter = new Counter(); Counter counter = new Counter();
 +ArrayList<Thread> threads = new ArrayList<>();
  
 for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
Zeile 100: Zeile 110:
    Thread t = new Thread(inc);    Thread t = new Thread(inc);
    t.setName("Thread " + i);    t.setName("Thread " + i);
 +   threads.add(t);
    t.start();    t.start();
 } }
 +
 +for (var t : threads) {
 +   t.join();
 +}
 +
 +println("Der Counter steht jetzt auf: "); print(counter.counter, Color.lightgreen);
  
 class Counter { class Counter {
Zeile 129: Zeile 146:
       for (long i = 1; i <= increment; i++) {       for (long i = 1; i <= increment; i++) {
          counter.increment();          counter.increment();
-         if(i % (increment/10) == 0) println(Thread.currentThread().getName() + " hat " + i + " mal erhöht!");+         if(i % (increment / 10) == 0) println(Thread.currentThread().getName() + " hat " + i + " mal erhöht!");
       }       }
-      println(Thread.currentThread().getName() + "\nDone! Counter steht auf: " + counter.counter, Color.lightgreen);+      println(Thread.currentThread().getName() + "\nDone!", Color.lightblue);
    }    }
  
Zeile 149: Zeile 166:
 <WRAP center round info 80%> <WRAP center round info 80%>
 Ein **Semaphor** ist ein Objekt, das einen Zähler enthält, dessen Wert angibt, von wie vielen Prozessen ein kritischer Abschnitt im Augenblick gerade noch betreten werden darf. \\  (**Bem.:** Eine andere Interpretation besteht darin, dass es $n$ gleichartig Ressourcen gibt. Der Wert des Zählers gibt an, wie viele im Augenblick gerade zur Verfügung stehen.) \\ \\ Der Semaphor besitzt zwei Methoden: Ein **Semaphor** ist ein Objekt, das einen Zähler enthält, dessen Wert angibt, von wie vielen Prozessen ein kritischer Abschnitt im Augenblick gerade noch betreten werden darf. \\  (**Bem.:** Eine andere Interpretation besteht darin, dass es $n$ gleichartig Ressourcen gibt. Der Wert des Zählers gibt an, wie viele im Augenblick gerade zur Verfügung stehen.) \\ \\ Der Semaphor besitzt zwei Methoden:
-  * ''aquire()'' prüft, ob der Zähler größer als 0 ist. +  * ''acquire()'' prüft, ob der Zähler größer als 0 ist. 
     * Ist dies der Fall, so wird der Zähler um eins erniedrigt und mit der danach folgenden Anweisung fortgefahren. Dem Prozess wird damit das Betreten des kritischen Bereichs gestattet.     * Ist dies der Fall, so wird der Zähler um eins erniedrigt und mit der danach folgenden Anweisung fortgefahren. Dem Prozess wird damit das Betreten des kritischen Bereichs gestattet.
     * Ist dies **nicht** der Fall, so wird der Prozess in einen Wartezustand versetzt. \\      * Ist dies **nicht** der Fall, so wird der Prozess in einen Wartezustand versetzt. \\ 
Zeile 163: Zeile 180:
 <script type="text/plain" title="Semaphore1.java"> <script type="text/plain" title="Semaphore1.java">
 Counter counter = new Counter(); Counter counter = new Counter();
 +ArrayList<Thread> threads = new ArrayList<>();
  
 for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
Zeile 168: Zeile 186:
    Thread t = new Thread(inc);    Thread t = new Thread(inc);
    t.setName("Thread " + i);    t.setName("Thread " + i);
 +   threads.add(t);
    t.start();    t.start();
 } }
 +
 +for (var t : threads) {
 +   t.join();
 +}
 +
 +println("\nDer Counter steht jetzt auf: "); print(counter.counter, Color.lightgreen);
 +
  
 class Counter { class Counter {
Zeile 175: Zeile 201:
    Semaphore semaphore = new Semaphore(1);    Semaphore semaphore = new Semaphore(1);
  
-   public synchronized void increment() {   // <-- mit Schlüsselwort synchronized! +   public void increment() {   
-      semaphore.aquire();+      semaphore.acquire();
       long i = counter;       long i = counter;
       i++;       i++;
Zeile 202: Zeile 228:
          counter.increment();          counter.increment();
       }       }
-      println("\nThread " + index + " done! Counter: " + counter.counter, Color.lightgreen);+      println("\nThread " + index + " done!", Color.lightblue);
    }    }
  
Zeile 227: Zeile 253:
    boolean locked = false;    boolean locked = false;
  
-   public void increment() {   // <-- mit Schlüsselwort synchronized!+   public void increment() {
       while (locked) {       while (locked) {
                    
Zeile 248: Zeile 274:
 <script type="text/plain" title="Semaphore1.java"> <script type="text/plain" title="Semaphore1.java">
 NaiveCounter counter = new NaiveCounter(); NaiveCounter counter = new NaiveCounter();
 +ArrayList<Thread> threads = new ArrayList<>();
  
 for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
Zeile 253: Zeile 280:
    Thread t = new Thread(inc);    Thread t = new Thread(inc);
    t.setName("Thread " + i);    t.setName("Thread " + i);
 +   threads.add(t);
    t.start();    t.start();
 } }
 +
 +for (var t : threads) {
 +   t.join();
 +}
 +
 +println("\nDer Counter steht jetzt auf: "); print(counter.counter, Color.coral);
 +
 +
  
 class NaiveCounter { class NaiveCounter {
Zeile 260: Zeile 296:
    boolean locked = false;    boolean locked = false;
  
-   public void increment() {   // <-- mit Schlüsselwort synchronized!+   public void increment() { 
       while (locked) {       while (locked) {
                    
Zeile 290: Zeile 326:
          if(i % (increment / 10) == 0) println(Thread.currentThread().getName() + " hat " + i + " mal erhöht!");          if(i % (increment / 10) == 0) println(Thread.currentThread().getName() + " hat " + i + " mal erhöht!");
       }       }
-      println(Thread.currentThread().getName() + "\nDone! Counter steht auf: " + counter.counter, Color.lightgreen);+      println(Thread.currentThread().getName() + "\nDone!", Color.lightgreen);
    }    }
  
Zeile 316: Zeile 352:
 Beide nutzen spezielle vom Mikroprozessor bereitgestellte Anweisungen, die garantiert **atomar** sind, d.h. der Prozessor stellt **hardwareseitig** sicher, dass während ihrer Ausführung keine andere Anweisung ausgeführt wird, auch nicht von einem anderen Prozessorkern.  Beide nutzen spezielle vom Mikroprozessor bereitgestellte Anweisungen, die garantiert **atomar** sind, d.h. der Prozessor stellt **hardwareseitig** sicher, dass während ihrer Ausführung keine andere Anweisung ausgeführt wird, auch nicht von einem anderen Prozessorkern. 
  \\ \\   \\ \\ 
-In diesem [[https://c9x.me/x86/html/file_module_x86_id_328.html|Auszug des instruction sets eines eines X86-Prozessors]] wird insbesondere die atomare XCHG-Anweisung vorgestellt, die den Wert eines Registers mit dem einer Speicherzelle vertauscht. Register sind Speicherzellen innerhalb des Prozessorkerns, die **garantiert nur jeweils von einem Thread** genutzt werden. Beschreiben Sie, wie diese Anweisung genutzt werden kann, um wechselseitigen Ausschluss zu erreichen. \\ \\ +In diesem [[https://c9x.me/x86/html/file_module_x86_id_328.html|Auszug des instruction sets eines eines X86-Prozessors]] wird insbesondere die atomare XCHG-Anweisung vorgestellt, die den Wert eines Registers mit dem einer Speicherzelle vertauscht. Register sind Speicherzellen innerhalb des Prozessorkerns, die **garantiert nur jeweils von einem Thread** genutzt werden. 
  
-  * In [[https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=30e83735eb72af97e7ab3ec7f0823b9a9ae5493c|Kapitel 2.1 dieses wissenschaftlichen Artikels]] noch weitere Beispiele ähnlicher atomarer Anweisung anderer Prozessoren.+  * Beschreiben Sie, wie diese Anweisung genutzt werden kann, um wechselseitigen Ausschluss zu erreichen.
   * Warum sind diese atomaren Anweisungen - verglichen mit nicht-atomaren Anweisungen, die dasselbe leisten - mit einer kleinen Performance-Einbuße verbunden?   * Warum sind diese atomaren Anweisungen - verglichen mit nicht-atomaren Anweisungen, die dasselbe leisten - mit einer kleinen Performance-Einbuße verbunden?
 +
 +In [[https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=30e83735eb72af97e7ab3ec7f0823b9a9ae5493c|Kapitel 2.1 dieses wissenschaftlichen Artikels]] noch weitere Beispiele ähnlicher atomarer Anweisung anderer Prozessoren.
    
 </WRAP> </WRAP>
parallelism/monitor/start.1735851263.txt.gz · Zuletzt geändert: 2025/01/02 20:54 von Martin Pabst
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki