重现java.io.IOException: Stream closed异常

于 2008-04-09 06:20:00 发布
阅读量2.5k 收藏 3
点赞数
文章标签： stream null input thread string class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hejishan/article/details/2267260
版权
上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



上午，美国的QA报告了一个的异常：

Caused by: java.io.IOException: Stream closed
at java.io.BufferedInputStream.getInIfOpen(BufferedInputStream.java:134)
at java.io.BufferedInputStream.fill(BufferedInputStream.java:218)
at java.io.BufferedInputStream.read(BufferedInputStream.java:235)
at ........

 这个异常发生在从某一个input stream流读取信息的时候发生的。在我们目前的系统中出现这个异常是比较不正常，特别是这个异常并不是很容易重现。我和本地的QA都没有重现出来。

虽然不能重现bug，但是凭借经验来说，这个异常是发生在这样一种场景之下：多个线程索引同一个input stream，当某一个thread在执行完之后，把这个inputstream关闭了；而此时正在从这个input stream流中读取信息的线程就会抛出 java.io.IOException: Stream closed 异常。

我写了一小段测试程序，模拟这个场景，如下：

public   class  IOTest  {
    public static void main(String[] args) {
        File f = new File("c:/test/StoreTest-1.xml");
        java.io.BufferedReader br = null;
        try {
            br = new java.io.BufferedReader(new java.io.FileReader(f));
        } catch (FileNotFoundException e) {}

        final java.io.BufferedReader br1 = br;
        final java.io.BufferedReader br2 = br;

        Thread t = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br1.readLine()) != null;) {
                        System.out.println("Process stdout: " );
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {}
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                try {
                    for (String line = null; (line = br2.readLine()) != null;) {}
                    System.out.println("Process stdout2: ");
                    br2.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        };

        t.start();
        t2.start();
    }
}

当执行这段程序之后，会看到如下输出：
Process stdout:
Process stdout2:
java.io.IOException: Stream closed
 at java.io.BufferedReader.ensureOpen(BufferedReader.java:97)
 at java.io.BufferedReader.readLine(BufferedReader.java:293)
 at java.io.BufferedReader.readLine(BufferedReader.java:362)
 at test.common.util.IOTest$1.run(IOTest.java:38)



hejishan
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值