Java 使用信号量的变量结果

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

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

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

---

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

或：

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

                        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

2.1s.发布（）；1许可证
1.1 s.获取（）；0许可证
2.2 s.释放（）；1许可证
1.2 s.获取（）；0许可证
1.3 int tmp=x；
1.4 s.释放（）；1许可证
2.3 s.获取（）；0许可证
2.4 int tmp=y；
2.5 s.释放（）；1许可证
1.5 tmp=tmp*2；2.6 tmp=tmp*3；
2.7 s.获取（）；0许可证
2.8 x=tmp+1；
2.9 s.释放（）；1许可证
1.6 s.获取（）；0许可证
1.7 y=tmp+1；
1.8 s.释放（）；1许可证

---

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

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

或：

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

                        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

2.1s.发布（）；1许可证
1.1 s.获取（）；0许可证
2.2 s.释放（）；1许可证
1.2 s.获取（）；0许可证
1.3 int tmp=x；
1.4 s.释放（）；1许可证
2.3 s.获取（）；0许可证
2.4 int tmp=y；
2.5 s.释放（）；1许可证
1.5 tmp=tmp*2；2.6 tmp=tmp*3；
2.7 s.获取（）；0许可证
2.8 x=tmp+1；
2.9 s.释放（）；1许可证
1.6 s.获取（）；0许可证
1.7 y=tmp+1；
1.8 s.释放（）；1许可证

---

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

请将您的代码以文本格式发布在这里。谢谢您的提及，我编辑了它！请将您的代码以文本形式发布在这里。谢谢您的提及，我编辑了它！谢谢你，先生，这很有帮助。有没有可能因为线程1和2在1.1和1.2中被阻塞而最终没有输出？如果线程1在1.1中被阻塞，那么它就不能到达1.2，线程2可以运行完成。您基本上描述了上面的第二个示例，只是有足够的许可证，所以线程1不会阻塞。谢谢，先生，这非常有用。有没有可能因为线程1和2在1.1和1.2中被阻塞而最终没有输出？如果线程1在1.1中被阻塞，那么它就不能到达1.2，线程2可以运行完成。您基本上是在描述上面的第二个示例，只是有足够的许可证，所以线程1不会阻塞。

                        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

                        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