今天闲来无事，尝试一下java的多进程，说是java的多进程，其实，我的目的还是java的io重定向。之前在我的这个博客中已经介绍过c/c++的io重定向了，这里介绍一下使用java的，首先先给出一个失败的版本。有两个文件Main.java和Test.java

Main.java是父进程，用于调用子进程Test.java

  1. //Main.java
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStreamWriter;
  6. import java.io.PrintWriter;
  7. import java.util.Scanner;
  9. public class Main
  10. {
  11.     private static PrintWriter pw = null;
  12.     private static BufferedReader br = null;
  13.     public static void main(String[] args)
  14.     {
  15.         Runtime r = Runtime.getRuntime();
  16.         try
  17.         {
  18.             Process p = r.exec("java -cp %classpath; Test");
  19.             br = new BufferedReader(new InputStreamReader(p.getInputStream()));
  20.             pw = new PrintWriter(new OutputStreamWriter(p.getOutputStream()));
  21.             String line;
  22.             new Thread(new Runnable()
  23.             {
  24.                 @Override
  25.                 public void run()
  26.                 {
  27.                     String line ;
  28.                     try
  29.                     {
  30.                         while ((line = br.readLine()) != null)
  31.                         {
  32.                             System.out.println(line);
  33.                         }
  34.                     }
  35.                     catch (IOException e)
  36.                     {
  37.                         e.printStackTrace();
  38.                     }
  39.                 }
  40.             }).start();
  41.             Scanner input = new Scanner(System.in);
  42.             while ((line = input.next()) != null)
  43.             {
  44.                 System.out.println(line);
  45.                 pw.print(line + '\r' + '\n');
  46.             }
  47.             System.out.println("end");
  48.             input.close();
  49.             pw.close();
  50.             br.close();
  51.         }
  52.         catch (IOException e)
  53.         {
  54.             e.printStackTrace();
  55.         }
  56.     }
  57. }

再来是 Test.java

  1. //Test.java
  2. import java.util.Scanner;
  5. public class Test
  6. {
  7.     public static void main(String[] args)
  8.     {
  9.         Scanner input = new Scanner(System.in);
  10.         String line ;
  12.         System.out.println("Hello\nWorld");
  14.         new Thread(new Runnable()
  15.         {
  16.             @Override
  17.             public void run()
  18.             {
  19.                 int count = 0;
  20.                 while (true)
  21.                 {
  22.                     System.out.printf("CurrendCount: %4d\r\n", count++);
  23.                     try
  24.                     {
  25.                         Thread.sleep(2000);
  26.                     }
  27.                     catch (InterruptedException e)
  28.                     {
  29.                         e.printStackTrace();
  30.                     };
  31.                 }
  32.             }
  33.         }).start();;
  34.         while ((line = input.nextLine()) != null)
  35.         {
  36.             System.out.println(line);
  37.         }
  39.         input.close();
  40.     }
  41. }

首先，你需要先编译 Test.java，然后再编译运行Main.java，注意Test的路径。

也许在你尝试之后，你发现在Main中输入什么都不会有响应，之前说过，这个程序是有问题的，问题不大，关键在于输出之后没有清除缓存，解决方法为：在 Main.java 中，在这个 while 循环中加入一句 pw.flush() 即可。

  1. while ((line = input.next()) != null)
  2. {
  3.     System.out.println(line);
  4.     pw.print(line + '\r' + '\n');
  5.     pw.flush();
  6. }

最后，再运行一次程序，发现OK，这就是Java IO重定向的简单示例，更多内容请关注我的详解日志。