Java：在子流程完成后使用相同的子流程变量安全吗？

当前一个子流程完成时，重用同一变量创建另一个子流程是否安全

String cmd = nextCmd();
        while(waitForNext) {
            Process p = Runtime.getRuntime().exec(cmd);
            String iLine = null;
            String eLine = null;
            BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
            BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream()));
            while((iLine = in.readLine())!=null 
                    || (eLine = err.readLine())!=null) {
                // just to clean the Streams
            }
            p.waitFor();
            cmd = nextCmd();
        }

如果循环持续数千次（例如），它是否有资格获得GC'd

如果前一个子流程完成，使用同一变量创建另一个子流程是否安全

String cmd = nextCmd();
        while(waitForNext) {
            Process p = Runtime.getRuntime().exec(cmd);
            String iLine = null;
            String eLine = null;
            BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
            BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream()));
            while((iLine = in.readLine())!=null 
                    || (eLine = err.readLine())!=null) {
                // just to clean the Streams
            }
            p.waitFor();
            cmd = nextCmd();
        }

对。如果子流程没有完成，也很安全，因为您将使用新值（新对象引用）完全替换存储在

p

中的值

---

事实上，所显示的循环中的赋值根本没有覆盖上一个值。当一个新的迭代开始时，因为你已经在块中声明了你的变量，它要么在每次迭代中都是一个新的变量，要么被当作是一个新的变量来对待（你可以用任何一种方式来看待它，可能；字节码可能反映了后者，但我认为理论反映了前者）。赋值是给（新）变量一个初始值，而不是覆盖上一次迭代的值。如果将

进程p

声明移到循环之外，则将覆盖它。那还是可以的。：-）

这种语言概念不一定会转化为字节码（更实用），但作为一种语言概念是正确的。例如，您可以向

p

添加一个

final

修饰符，这样就可以了。下次就不一样了

如果前一个子流程完成，使用同一变量创建另一个子流程是否安全

String cmd = nextCmd();
        while(waitForNext) {
            Process p = Runtime.getRuntime().exec(cmd);
            String iLine = null;
            String eLine = null;
            BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
            BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream()));
            while((iLine = in.readLine())!=null 
                    || (eLine = err.readLine())!=null) {
                // just to clean the Streams
            }
            p.waitFor();
            cmd = nextCmd();
        }

对。如果子流程没有完成，也很安全，因为您将使用新值（新对象引用）完全替换存储在

p

中的值

---

事实上，所显示的循环中的赋值根本没有覆盖上一个值。当一个新的迭代开始时，因为你已经在块中声明了你的变量，它要么在每次迭代中都是一个新的变量，要么被当作是一个新的变量来对待（你可以用任何一种方式来看待它，可能；字节码可能反映了后者，但我认为理论反映了前者）。赋值是给（新）变量一个初始值，而不是覆盖上一次迭代的值。如果将

进程p

声明移到循环之外，则将覆盖它。那还是可以的。：-）

这种语言概念不一定会转化为字节码（更实用），但作为一种语言概念是正确的。例如，您可以向

p

添加一个

final

修饰符，这样就可以了。下次就不一样了

如果前一个子流程完成，使用同一变量创建另一个子流程是否安全

String cmd = nextCmd();
        while(waitForNext) {
            Process p = Runtime.getRuntime().exec(cmd);
            String iLine = null;
            String eLine = null;
            BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
            BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream()));
            while((iLine = in.readLine())!=null 
                    || (eLine = err.readLine())!=null) {
                // just to clean the Streams
            }
            p.waitFor();
            cmd = nextCmd();
        }

对。如果子流程没有完成，也很安全，因为您将使用新值（新对象引用）完全替换存储在

p

中的值

---

事实上，所显示的循环中的赋值根本没有覆盖上一个值。当一个新的迭代开始时，因为你已经在块中声明了你的变量，它要么在每次迭代中都是一个新的变量，要么被当作是一个新的变量来对待（你可以用任何一种方式来看待它，可能；字节码可能反映了后者，但我认为理论反映了前者）。赋值是给（新）变量一个初始值，而不是覆盖上一次迭代的值。如果将

进程p

声明移到循环之外，则将覆盖它。那还是可以的。：-）

这种语言概念不一定会转化为字节码（更实用），但作为一种语言概念是正确的。例如，您可以向

p

添加一个

final

修饰符，这样就可以了。下次就不一样了

如果前一个子流程完成，使用同一变量创建另一个子流程是否安全

String cmd = nextCmd();
        while(waitForNext) {
            Process p = Runtime.getRuntime().exec(cmd);
            String iLine = null;
            String eLine = null;
            BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
            BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream()));
            while((iLine = in.readLine())!=null 
                    || (eLine = err.readLine())!=null) {
                // just to clean the Streams
            }
            p.waitFor();
            cmd = nextCmd();
        }

对。如果子流程没有完成，也很安全，因为您将使用新值（新对象引用）完全替换存储在

p

中的值

---

事实上，所显示的循环中的赋值根本没有覆盖上一个值。当一个新的迭代开始时，因为你已经在块中声明了你的变量，它要么在每次迭代中都是一个新的变量，要么被当作是一个新的变量来对待（你可以用任何一种方式来看待它，可能；字节码可能反映了后者，但我认为理论反映了前者）。赋值是给（新）变量一个初始值，而不是覆盖上一次迭代的值。如果将

进程p

声明移到循环之外，则将覆盖它。那还是可以的。：-）

这种语言概念不一定会转化为字节码（更实用），但作为一种语言概念是正确的。例如，您可以向

p

添加一个

final

修饰符，这样就可以了。下次就不一样了。

在这样的循环中：

   while(waitForNext) {
        Process p = Runtime.getRuntime().exec(cmd);
        // ...
        p.waitFor();
        cmd = nextCmd();
    }

您不是在“重用变量”（p）。离开块时，变量超出范围。重新输入它，将创建一个新变量

这是重复使用变量p，根据您的问题，这是安全的

Process p = Runtime.getRuntime().exec(cmd);
// ...
p.waitFor();
p = Runtime.getRuntime().exec(anotherCmd);
// ...
p.waitFor();

以后

由于字节码T.J.Crowder故意添加到他的答案中，我们必须说，这是否是“同一个变量”的问题（我想说：）是无法确定的。字节码表明变量在循环体的末尾没有被“销毁”，但无论如何都不能使用上一次迭代的值，因为在第二次迭代中不初始化和尝试访问变量会被编译器阻止。

在这样的循环中：

   while(waitForNext) {
        Process p = Runtime.getRuntime().exec(cmd);
        // ...
        p.waitFor();
        cmd = nextCmd();
    }

您不是在“重用变量”（p）。离开块时，变量超出范围。重返