Ergebnis Variablen Semaphore

Question

Semaphore s = new Semaphore (0); 
int x = 7; 
int y = 1; 

1.1 s.acquire();   2.1 s.release(); 
          2.2. s.release(); 
1.2 s.aquire();    2.3 s.acquire(); 
1.3 int tmp = x;   2.4 int tmp = y; 
1.4 s.release();   2.5 s.release(); 

1.5. tmp = tmp * 2;   2.6 tmp = tmp * 3; 

1.6. s.acquire();   2.7 s.acquire(); 
1.7 y = tmp + 1;   2.8 x = tmp + 1; 
1.8. s.release();   2.9 s.release(); 

semaphore program

Ich habe Mühe, das Ergebnis dieser Variablen x und y, wenn diese beiden Threads parallel ausgeführt werden.

1. Das Semaphor hat 0 Genehmigungen? Die einzige mögliche Ausgabe hier sollte also x = 7, y = 1 sein, oder?

2. Ich verstehe die verschachtelte acquires() und releases() nicht. Was wäre das Ergebnis von x und y wenn ifsemaphore 2 Genehmigungen hätte?

Answer 1

Da es keine Verzögerungen im Code sind, kann es in vielerlei Hinsicht laufen, je nachdem, welche CPU ist schneller, oder wie die OS planen die Fäden (zB in Single-CPU-System):

     2.1 s.release();  1 permit 
         2.2 s.release();  2 permits 
1.1 s.acquire();        1 permit 
1.2 s.acquire();        0 permits 
1.3 int tmp = x; 
1.4 s.release();        1 permit 
1.5 tmp = tmp * 2; 
1.6 s.acquire();        0 permits 
1.7 y = tmp + 1; 
1.8 s.release();        1 permit 
         2.3 s.acquire();  0 permits 
         2.4 int tmp = y; 
         2.5 s.release();  1 permit 
         2.6 tmp = tmp * 3; 
         2.7 s.acquire();  0 permits 
         2.8 x = tmp + 1; 
         2.9 s.release();  1 permit 

Oder

:

     2.1 s.release();   1 permit 
         2.2 s.release();   2 permits 
         2.3 s.acquire();   1 permit 
         2.4 int tmp = y; 
         2.5 s.release();   2 permits 
         2.6 tmp = tmp * 3; 
         2.7 s.acquire();   1 permit 
         2.8 x = tmp + 1; 
         2.9 s.release();   2 permits 
1.1 s.acquire();         1 permit 
1.2 s.acquire();         0 permits 
1.3 int tmp = x; 
1.4 s.release();         1 permit 
1.5 tmp = tmp * 2; 
1.6 s.acquire();         0 permits 
1.7 y = tmp + 1; 
1.8 s.release();         1 permit 

Was kann nicht passieren, ist für die Schritte 1.3 und 2.4 parallel laufen zu lassen. Dafür gibt es nicht genug Genehmigungen.

     2.1 s.release();   1 permit 
1.1 s.acquire();         0 permits 
         2.2 s.release();   1 permit 
1.2 s.acquire();         0 permits 
1.3 int tmp = x;   <blocked> 
1.4 s.release();   <blocked>    1 permit 
         2.3 s.acquire();   0 permits 
         2.4 int tmp = y; 
         2.5 s.release();   1 permit 
1.5 tmp = tmp * 2;  2.6 tmp = tmp * 3; 
         2.7 s.acquire();   0 permits 
    <blocked>    2.8 x = tmp + 1; 
    <blocked>    2.9 s.release();   1 permit 
1.6 s.acquire();         0 permits 
1.7 y = tmp + 1; 
1.8 s.release();         1 permit 

Es gibt viele andere Möglichkeiten, wie diese zwei Threads verschachtelt werden können.