java 当尝试使用信号量时，只有一个线程执行[关闭]

afdcj2ne  于 2024-01-05  发布在  Java
关注(0)|答案(1)|浏览(238)

**已关闭。**此问题需要debugging details。目前不接受回答。

编辑问题以包括desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem。这将帮助其他人回答问题。
4天前关闭。
社区在4天前审查了是否重新打开此问题，并将其关闭：

不适合本网站此问题是由错别字或无法再复制的问题引起的。虽然类似的问题可能是on-topic在这里，但这一个问题的解决方式不太可能帮助未来的读者。

Improve this question的
根据我的理解，java.util.concurrent.Semaphore允许我指定一次可以有多少个线程使用一个资源。一个线程可以使用Semaphore.acquireUninterruptibly()来消耗信号量中有限数量的“插槽”。一旦线程完成，应该调用Semaphore.release()以给予插槽，以便另一个正在等待的线程（acquireUninterruptibly()使线程等待）可以抓住新的插槽。我知道公平策略，线程的顺序与我的目的无关。重要的是所有线程都执行。
这就是我的问题--只有一个线程执行。下面是我的代码。

  1. import java.nio.file.Path;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.concurrent.Semaphore;
  5.  
  6. public class Main
  7. {
  8.  
  9.    private static final Path rootbarFolder = Path.of("C:", "Users");
  10.  
  11.    private boolean REATTEMPT_UPON_FAILURE = true;
  12.  
  13.    public static void main(final String[] args) throws Exception
  14.    {
  15.   
  16.       new Main();
  17.   
  18.    }
  19.  
  20.    private Main() throws Exception
  21.    {
  22.   
  23.       javax.swing.SwingUtilities
  24.          .invokeLater
  25.          (
  26.             () ->
  27.             {
  28.            
  29.                javax.swing.JOptionPane.showMessageDialog(null, "Close this popup window to make the program exit on failure");
  30.            
  31.                this.REATTEMPT_UPON_FAILURE = false;
  32.            
  33.             }
  34.          )
  35.          ;
  36.   
  37.       final List<Path> fooPathList = this.getListOfbarfooPaths();
  38.   
  39.       final List<Thread> fooPathThreads = new ArrayList<>();
  40.   
  41.       final Semaphore semaphore = new Semaphore(1, true);
  42.   
  43.       KICK_OFF_THREADS:
  44.       for (final Path fooPath : fooPathList)
  45.       {
  46.      
  47.          final Thread fooPathThread = this.createThread(semaphore, fooPath);
  48.      
  49.          fooPathThreads.add(fooPathThread);
  50.      
  51.          semaphore.acquireUninterruptibly();
  52.      
  53.          fooPathThread.start();
  54.         
  55.       }
  56.   
  57.       JOIN_THREADS:
  58.       for (final Thread fooPathThread : fooPathThreads)
  59.       {
  60.      
  61.          fooPathThread.join();
  62.         
  63.       }
  64.   
  65.    }
  66.  
  67.    private Thread createThread(final Semaphore semaphore, final Path fooPath)
  68.    {
  69.   
  70.       return
  71.          Thread
  72.             .ofPlatform()
  73.             .unstarted
  74.             (
  75.                () ->
  76.                {
  77.               
  78.                   try
  79.                   {
  80.                  
  81.                      int exitCode = -1;
  82.                  
  83.                      while (exitCode != 0 && this.REATTEMPT_UPON_FAILURE)
  84.                      {
  85.                     
  86.                         System.out.println("\n\nAttempting " + fooPath);
  88.                         final Process fooProcess = this.createzilklaquo(fooPath);
  89.                     
  90.                         exitCode =                             //Tells us the status of the run
  91.                            fooProcess.waitFor();           //Don't close down the JVM before this process finishes running!
  92.                     
  93.                         System.out.println(fooPath + " -- fooProcess exitCode = " + exitCode);
  94.                         Thread.sleep(10_000);
  95.                     
  96.                      }
  97.                  
  98.                   }
  99.                  
  100.                   catch (final Exception exception)
  101.                   {
  102.                  
  103.                      throw new RuntimeException(exception);
  104.                  
  105.                   }
  106.                  
  107.                   finally
  108.                   {
  109.                  
  110.                      semaphore.release();
  111.                  
  112.                   }
  113.               
  114.                }
  115.             )
  116.             ;
  117.   
  118.    }
  119.  
  120.    private Process createzilklaquo(final Path fooPath)
  121.    {
  122.   
  123.       try
  124.       {
  125.      
  126.          final ProcessBuilder fooProcessBuilder =
  127.             new
  128.                ProcessBuilder
  129.                (
  130.                   "cmd",
  131.                   "/C",
  132.                   "THIS_COMMAND_WILL_FAIL"
  133.                )
  134.                .directory
  135.                (
  136.                   rootbarFolder              //
  137.                      .resolve(fooPath)      //
  138.                      .toFile()                  //
  139.                )
  140.                .inheritIO()
  141.                ;
  142.      
  143.          fooProcessBuilder
  144.             .environment()
  145.             .put("SUB_FOLDER", fooPath.getFileName().toString())
  146.             ;
  147.      
  148.          final Process fooProcess =
  149.             fooProcessBuilder
  150.                .start()                            //Kicks off the newly created Process
  151.                ;
  152.      
  153.          // final int exitCode =                   //Tells us the status of the run
  154.             // fooProcess.waitFor();           //Don't close down the JVM before this process finishes running!
  155.       //
  156.          // System.out.println("fooProcess exitCode = " + exitCode);
  157.      
  158.          return fooProcess;
  159.      
  160.       }
  161.      
  162.       catch (final Exception e)
  163.       {
  164.      
  165.          throw new RuntimeException(e);
  166.      
  167.       }
  168.   
  169.    }
  170.  
  171.    private List<Path> getListOfbarfooPaths() throws Exception
  172.    {
  173.   
  174.       final Process fooListProcess =
  175.          new
  176.             ProcessBuilder
  177.             (
  178.                "cmd",                        //Since this is Windows, CMD is the easiest way to accomplish what we want
  179.                "/C",                         //Starts an instance of CMD, does the below commands, outputs/pipes them, then immediately closes
  180.                "dir",                        //Lists all contents in the folder
  181.                "/A:D",                       //Filters the contents down to only directories
  182.                "/B"                          //Removes extra metadata -- just the names
  183.             )
  184.             .directory
  185.             (
  186.                rootbarFolder              //Perform the action in the root bar folder
  187.                   .toFile()                  //Wish I could give a Path instead of a File
  188.             )
  189.             //.inheritIO()                     //Forward all Input and Output to the same as Java's (commented out because it drowns out my logs)
  190.             .start()                         //Kicks off the newly created Process
  191.             ;
  192.   
  193.       final int exitCode =                   //Tells us the status of the run
  194.          fooListProcess.waitFor();       //Don't close down the JVM before this process finishes running!
  195.   
  196.       System.out.println("fooListProcess exitCode = " + exitCode);
  197.   
  198.       final String fooListRawOutput =    //The raw output from the newly created process
  199.          new
  200.             String
  201.             (
  202.                fooListProcess            //Now that the process has finished, we can pull from it
  203.                   .getInputStream()          //The way that you quo the OUTPUT of the process is to call getINPUTStream -- very unintuitive
  204.                   .readAllBytes()            //Let's quo all of it
  205.             )
  206.             ;
  207.   
  208.       final List<Path> fooList =       //The list of foos that we will be working with
  209.          fooListRawOutput                //We will be extracting it from the raw output
  210.             .lines()                         //It's a new-line-separated list, so split by line
  211.             .map(rootbarFolder::resolve)  //Turn it into a Path that is the rootbarFolder resolved to the sub-folder -- root -> root/subFolder
  212.             .toList()                        //Finally, put the contents into a list
  213.             ;
  214.   
  215.       fooList.forEach(System.out::println);
  216.   
  217.       return fooList;
  218.   
  219.    }
  220.  
  221. }

字符串
同样，这是一个假的例子，基于一个真实的例子，我不能显示，因为公司的政策。
我有一个文件夹，里面有很多文件夹。举个例子，我把它指向Windows C：/驱动器中的Users文件夹。如果你是Linux或其他系统，可以随意更改顶部的Path变量，使其指向机器上的其他目录。但要让它成为一个目录，该目录中有多个项目。
所以，在我的机器上，这里是我的C：/Users文件夹中的文件夹。

  1. C:\Users\All Users
  2. C:\Users\david
  3. C:\Users\Default
  4. C:\Users\Default User
  5. C:\Users\Public

型
但是当我运行这个程序时，它只会为C:\Users\All Users生成一个print语句，而不会为其他行生成一个print语句，这意味着这个程序没有尝试其他线程。
这就是它打印的内容。

  1. $ java Main.java
  2. fooListProcess exitCode = 0
  3. C:\Users\All Users
  4. C:\Users\david
  5. C:\Users\Default
  6. C:\Users\Default User
  7. C:\Users\Public
  8. Attempting C:\Users\All Users
  9. 'THIS_COMMAND_WILL_FAIL' is not recognized as an internal or external command,
  10. operable program or batch file.
  11. C:\Users\All Users -- fooProcess exitCode = 1

型
因此，我们可以看到它尝试了所有用户文件夹，但随后它就停止了。
我以为会是这样的。

  1. java Main.java
  2. fooListProcess exitCode = 0
  3. C:\Users\All Users
  4. C:\Users\david
  5. C:\Users\Default
  6. C:\Users\Default User
  7. C:\Users\Public
  8. Attempting C:\Users\All Users
  9. 'THIS_COMMAND_WILL_FAIL' is not recognized as an internal or external command,
  10. operable program or batch file.
  11. C:\Users\All Users -- fooProcess exitCode = 1
  12. Attempting C:\Users\david
  13. 'THIS_COMMAND_WILL_FAIL' is not recognized as an internal or external command,
  14. operable program or batch file.
  15. C:\Users\david -- fooProcess exitCode = 1
  17. ...repeat for all other folders

型
但是，无论如何，我想做多线程来做一些关于这些线程的工作。我正在做的工作经常失败，所以我有一个while循环来监听exitCode，然后重试。然而，由于我不能说的原因，我需要有一个逃生舱口，它说“从现在开始，任何未来的失败都应该结束线程的执行”。这就是JOptionPane的作用。我知道这是一个糟糕的例子，但重点是它切换了一个boolean标志，这就是我需要它做的。
但我的问题是，当我切换标志时，应该在信号量上等待空闲插槽的后续线程没有被踢出。
至于上面的代码实际上在做什么，它尝试了一个肯定会失败的命令，触发了我提到的while循环机制。然后，线程休眠10秒，然后再试一次。
我有一个弹出窗口，允许我设置标志时，我选择按确定。当我这样做，第一个线程完成，但下一个线程永远不会开始。
现在，我知道JVM可以采用多线程“捷径”（因为没有更好的术语），这很可能就是这里发生的事情，但我不知道这是否是原因。
为什么我的其他线程没有被踢掉？

编辑-我注意到一些接近的投票，声称我的问题与StackOverflow无关。不幸的是，这太宽泛了，我不知道如何改进我的问题。

我的整个问题是--我很难理解为什么Java标准库中的基本库没有做我认为它们应该做的事情。我清楚地传达了我对它们的理解，我展示了我的尝试，我的示例简单，最小化，可重复（就我的电脑可以告诉，无论如何）。如果有什么进一步的我应该做的，或者我没有做什么，请让我知 prop 体，以便我可以作出改变。

编辑2-哦，显然，如果你点击关闭的投票，然后点击选择，他们会进入更详细.不是很直观，但我现在明白了.

我已经添加了所有要求的信息。令人尴尬的是，这也给了我一个正确的方向，我能够自己解决它。随时发布答案，但解决方案非常简单。

Java

1条答案

按热度按时间
nimxete2

nimxete21#

我真傻，看看那个while的条件。

  1. while (exitCode != 0 && this.REATTEMPT_UPON_FAILURE)

字符串
&&
这意味着一旦我们将标志设置为false，就没有其他东西会进入while循环。一个潜在的解决方案是do-while循环。

赞(0）分享  回复(0）举报  2024-01-05
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com