使用信号量的变量的java结果

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

如果这两个线程并行运行，我很难得到这些变量x和y的结果

1. 信号灯有0个许可证？所以这里唯一可能的输出应该是x=7，y=1，不是吗

2. 我不理解嵌套的acquires（）和release（）。如果信号量有两个许可证，x和y的结果会是什么

Answer 1

由于代码中没有延迟，它可以以多种方式运行，具体取决于哪个CPU更快，或者操作系统如何安排线程（例如，在单CPU系统中）：

                        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

或者：

                        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

不可能发生的事情是让步骤1.3和2.4并行运行。没有足够的许可证

                        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

这两个线程可以通过许多其他方式交错