Java 调用 shell 脚本详解

2022-11-11 13:01:55

这一年的项目中，有大量的场景需要Java 进程调用 Linux的bash shell 脚本实现相关功能。

从之前的项目中拷贝的相关模块和网上的例子来看，有个别的“陷阱”造成调用shell 脚本在某些特殊的场景下，有一些奇奇怪怪的bug。

大家且听我一一道来。

先看看网上搜索到的例子：

  1. package someTest;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. public class ShellTest {
  6. public static void main(String[] args) {
  7. InputStreamReader stdISR = null;
  8. InputStreamReader errISR = null;
  9. Process process = null;
  10. String command = "/home/Lance/workspace/someTest/testbash.sh";
  11. try {
  12. process = Runtime.getRuntime().exec(command);
  13. int exitValue = process.waitFor();
  14. String line = null;
  15. stdISR = new InputStreamReader(process.getInputStream());
  16. BufferedReader stdBR = new BufferedReader(stdISR);
  17. while ((line = stdBR.readLine()) != null) {
  18. System.out.println("STD line:" + line);
  19. }
  20. errISR = new InputStreamReader(process.getErrorStream());
  21. BufferedReader errBR = new BufferedReader(errISR);
  22. while ((line = errBR.readLine()) != null) {
  23. System.out.println("ERR line:" + line);
  24. }
  25. } catch (IOException | InterruptedException e) {
  26. e.printStackTrace();
  27. } finally {
  28. try {
  29. if (stdISR != null) {
  30. stdISR.close();
  31. }
  32. if (errISR != null) {
  33. errISR.close();
  34. }
  35. if (process != null) {
  36. process.destroy();
  37. }
  38. } catch (IOException e) {
  39. System.out.println("正式执行命令：" + command + "有IO异常");
  40. }
  41. }
  42. }
  43. }

testbash.sh

  1. #!/bin/bash
  2. echo `pwd`

输出结果为：

  1. STD line:/home/Lance/workspace/someTest

Java在执行Runtime.getRuntime().exec(command)之后，Linux会创建一个进程，该进程与JVM进程建立三个管道连接，标准输入流、标准输出流、标准错误流。

上述代码，依次读取标准输出流和标准错误流，在shell给出“退出信号”后，做了相应的清理工作。

对于一般场景来说，这段代码可以凑合用了。但是，在实际场景中，会有以下几个“陷阱”。

一. 当标准输出流或标准错误流非常庞大的时候，会出现调用waitFor方法卡死的bug。

真实的环境中，当标准输出在10000行左右的时候，就会出现卡死的情况。

原因分析：假设linux进程不断向标准输出流和标准错误流写数据，而JVM却不读取，数据会暂存在linux缓存区，当缓存区存满之后导致该进程无法继续写数据，会僵死，导致java进程会卡死在waitFor()处，永远无法结束。

解决方式：由于标准输出和错误输出都会向Linux缓存区写数据，而脚本如何输出这两种流是Java端不能确定的。为了不让shell脚本的子进程卡死，这两种输出需要分别读取，而且不能互相影响。所以必须新开两个线程来进行读取。

我开始的实现如下：

  1. package someTest;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import java.util.LinkedList;
  7. import java.util.List;
  8. public class CommandStreamGobbler extends Thread {
  9. private InputStream is;
  10. private String command;
  11. private String prefix = "";
  12. private boolean readFinish = false;
  13. private boolean ready = false;
  14. private List<String> infoList = new LinkedList<String>();
  15. CommandStreamGobbler(InputStream is, String command, String prefix) {
  16. this.is = is;
  17. this.command = command;
  18. this.prefix = prefix;
  19. }
  20. public void run() {
  21. InputStreamReader isr = null;
  22. try {
  23. isr = new InputStreamReader(is);
  24. BufferedReader br = new BufferedReader(isr);
  25. String line = null;
  26. ready = true;
  27. while ((line = br.readLine()) != null) {
  28. infoList.add(line);
  29. System.out.println(prefix + " line: " + line);
  30. }
  31. } catch (IOException ioe) {
  32. System.out.println("正式执行命令：" + command + "有IO异常");
  33. } finally {
  34. try {
  35. if (isr != null) {
  36. isr.close();
  37. }
  38. } catch (IOException ioe) {
  39. System.out.println("正式执行命令：" + command + "有IO异常");
  40. }
  41. readFinish = true;
  42. }
  43. }
  44. public InputStream getIs() {
  45. return is;
  46. }
  47. public String getCommand() {
  48. return command;
  49. }
  50. public boolean isReadFinish() {
  51. return readFinish;
  52. }
  53. public boolean isReady() {
  54. return ready;
  55. }
  56. public List<String> getInfoList() {
  57. return infoList;
  58. }
  59. }
  1. package someTest;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. public class ShellTest {
  5. public static void main(String[] args) {
  6. InputStreamReader stdISR = null;
  7. InputStreamReader errISR = null;
  8. Process process = null;
  9. String command = "/home/Lance/workspace/someTest/testbash.sh";
  10. try {
  11. process = Runtime.getRuntime().exec(command);
  12. CommandStreamGobbler errorGobbler = new CommandStreamGobbler(process.getErrorStream(), command, "ERR");
  13. CommandStreamGobbler outputGobbler = new CommandStreamGobbler(process.getInputStream(), command, "STD");
  14. errorGobbler.start();
  15. // 必须先等待错误输出ready再建立标准输出
  16. while (!errorGobbler.isReady()) {
  17. Thread.sleep(10);
  18. }
  19. outputGobbler.start();
  20. while (!outputGobbler.isReady()) {
  21. Thread.sleep(10);
  22. }
  23. int exitValue = process.waitFor();
  24. } catch (IOException | InterruptedException e) {
  25. e.printStackTrace();
  26. } finally {
  27. try {
  28. if (stdISR != null) {
  29. stdISR.close();
  30. }
  31. if (errISR != null) {
  32. errISR.close();
  33. }
  34. if (process != null) {
  35. process.destroy();
  36. }
  37. } catch (IOException e) {
  38. System.out.println("正式执行命令：" + command + "有IO异常");
  39. }
  40. }
  41. }
  42. }

到此为止，解决了Java卡死shell脚本的情况。再说说，第二种可能。

二. 由于shell脚本的编写问题，当其自身出现僵死的情况，上述代码出现Java代码被僵死的Shell脚本阻塞住的情况。

原因分析：由于shell脚本也是人写的，难免会出现失误。在Java调用shell脚本时，无论是Debug场景还是生产环境，都发生过shell脚本意外僵死反过来卡死Java相关线程的情况。典型的表现为：shell脚本长时间运行，标准输出和错误输出没有任何输出（包括结束符），操作系统显示shell脚本在正常运行或僵死，没有退出信号。

解决方式：上述代码中，至少有三处会导致线程阻塞，包括标准输出和错误输出这线程的BufferedReader的readline方法，以及Process的waitFor方法。解决这个问题的核心有两个，1.避免任何Java线程被阻塞住，因为一旦被IO阻塞住，线程将处于内核态，主线程没有任何办法强制结束相关子线程。2.添加一个简单的超时机制，超时后回收相应的线程资源，并结束调用过程。

演示代码中，我改写了testshell.sh，写一个没有任何输出的死循环模拟shell卡死的情况。

  1. #!/bin/bash
  2. while true;do
  3. a=1
  4. sleep 0.1
  5. done
  1. package someTest;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import java.util.LinkedList;
  7. import java.util.List;
  8. public class CommandStreamGobbler extends Thread {
  9. private InputStream is;
  10. private String command;
  11. private String prefix = "";
  12. private boolean readFinish = false;
  13. private boolean ready = false;
  14. // 命令执行结果,0:执行中 1:超时 2:执行完成
  15. private int commandResult = 0;
  16. private List<String> infoList = new LinkedList<String>();
  17. CommandStreamGobbler(InputStream is, String command, String prefix) {
  18. this.is = is;
  19. this.command = command;
  20. this.prefix = prefix;
  21. }
  22. public void run() {
  23. InputStreamReader isr = null;
  24. BufferedReader br = null;
  25. try {
  26. isr = new InputStreamReader(is);
  27. br = new BufferedReader(isr);
  28. String line = null;
  29. ready = true;
  30. while (commandResult != 1) {
  31. if (br.ready() || commandResult == 2) {
  32. if ((line = br.readLine()) != null) {
  33. infoList.add(line);
  34. } else {
  35. break;
  36. }
  37. } else {
  38. Thread.sleep(100);
  39. }
  40. }
  41. } catch (IOException | InterruptedException ioe) {
  42. System.out.println("正式执行命令：" + command + "有IO异常");
  43. } finally {
  44. try {
  45. if (br != null) {
  46. br.close();
  47. }
  48. if (isr != null) {
  49. isr.close();
  50. }
  51. } catch (IOException ioe) {
  52. System.out.println("正式执行命令：" + command + "有IO异常");
  53. }
  54. readFinish = true;
  55. }
  56. }
  57. public InputStream getIs() {
  58. return is;
  59. }
  60. public String getCommand() {
  61. return command;
  62. }
  63. public boolean isReadFinish() {
  64. return readFinish;
  65. }
  66. public boolean isReady() {
  67. return ready;
  68. }
  69. public List<String> getInfoList() {
  70. return infoList;
  71. }
  72. public void setTimeout(int timeout) {
  73. this.commandResult = timeout;
  74. }
  75. }
  1. package someTest;
  2. public class CommandWaitForThread extends Thread {
  3. private Process process;
  4. private boolean finish = false;
  5. private int exitValue = -1;
  6. public CommandWaitForThread(Process process) {
  7. this.process = process;
  8. }
  9. public void run() {
  10. try {
  11. this.exitValue = process.waitFor();
  12. } catch (InterruptedException e) {
  13. e.printStackTrace();
  14. } finally {
  15. finish = true;
  16. }
  17. }
  18. public boolean isFinish() {
  19. return finish;
  20. }
  21. public void setFinish(boolean finish) {
  22. this.finish = finish;
  23. }
  24. public int getExitValue() {
  25. return exitValue;
  26. }
  27. }
  1. package someTest;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.util.Date;
  5. public class ShellTest {
  6. public static void main(String[] args) {
  7. InputStreamReader stdISR = null;
  8. InputStreamReader errISR = null;
  9. Process process = null;
  10. String command = "/home/Lance/workspace/someTest/testbash.sh";
  11. long timeout = 10 * 1000;
  12. try {
  13. process = Runtime.getRuntime().exec(command);
  14. CommandStreamGobbler errorGobbler = new CommandStreamGobbler(process.getErrorStream(), command, "ERR");
  15. CommandStreamGobbler outputGobbler = new CommandStreamGobbler(process.getInputStream(), command, "STD");
  16. errorGobbler.start();
  17. // 必须先等待错误输出ready再建立标准输出
  18. while (!errorGobbler.isReady()) {
  19. Thread.sleep(10);
  20. }
  21. outputGobbler.start();
  22. while (!outputGobbler.isReady()) {
  23. Thread.sleep(10);
  24. }
  25. CommandWaitForThread commandThread = new CommandWaitForThread(process);
  26. commandThread.start();
  27. long commandTime = new Date().getTime();
  28. long nowTime = new Date().getTime();
  29. boolean timeoutFlag = false;
  30. while (!commandIsFinish(commandThread, errorGobbler, outputGobbler)) {
  31. if (nowTime - commandTime > timeout) {
  32. timeoutFlag = true;
  33. break;
  34. } else {
  35. Thread.sleep(100);
  36. nowTime = new Date().getTime();
  37. }
  38. }
  39. if (timeoutFlag) {
  40. // 命令超时
  41. errorGobbler.setTimeout(1);
  42. outputGobbler.setTimeout(1);
  43. System.out.println("正式执行命令：" + command + "超时");
  44. }else {
  45. // 命令执行完成
  46. errorGobbler.setTimeout(2);
  47. outputGobbler.setTimeout(2);
  48. }
  49. while (true) {
  50. if (errorGobbler.isReadFinish() && outputGobbler.isReadFinish()) {
  51. break;
  52. }
  53. Thread.sleep(10);
  54. }
  55. } catch (IOException | InterruptedException e) {
  56. e.printStackTrace();
  57. } finally {
  58. if (process != null) {
  59. process.destroy();
  60. }
  61. }
  62. }
  63. private boolean commandIsFinish(CommandWaitForThread commandThread, CommandStreamGobbler errorGobbler, CommandStreamGobbler outputGobbler) {
  64. if (commandThread != null) {
  65. return commandThread.isFinish();
  66. } else {
  67. return (errorGobbler.isReadFinish() && outputGobbler.isReadFinish());
  68. }
  69. }
  70. }


在以上的代码中，为了防止线程被阻塞，要点如下：


1. 在CommandStreamGobbler里，bufferedReader在readLine()之前，先用ready()看一下当前缓冲区的情况，请特别注意ready()描述，这个方法是非阻塞的。




    

  1. boolean java.io.BufferedReader.ready() throws IOException
    2. 

  2. Tells whether this stream is ready to be read. A buffered character stream is ready if the buffer is not empty, or if the underlying character stream is ready.
    3. 

  3. Returns:
    4. 

  4. True if the next read() is guaranteed not to block for input, false otherwise. Note that returning false does not guarantee that the next read will block.
    5. 





2.在一个新线程commandThread中，调用process对象的waitFor()从而避免主线程卡死，主线程的最后会执行finally块中的process.destory()保证commandThread正常退出。


以上的两点改进，保证了Java在调用shell脚本过程互不被对方卡死的机制。


三.在执行shell脚本过程中，可能会添加参数，通常在终端中，我们使用“ ”（空格）把参数隔开。


为了区分空格是作为参数分隔符，还是参数的一部分。调用exec方法有特别的注意事项。




    

  1. String command = "/home/Lance/workspace/someTest/testbash.sh 'hello world'";
    2. 

  2. process = Runtime.getRuntime().exec(command);
    3. 





等价于




    

  1. List<String> commandList = new LinkedList<String>();
    2. 

  2. commandList.add("/home/Lance/workspace/someTest/testbash.sh");
    3. 

  3. commandList.add("hello world");
    4. 

  4. String[] commands = new String[commandList.size()];
    5. 

  5. for (int i = 0; i < commandList.size(); i++) {
    6. 

  6. commands[i] = commandList.get(i);
    7. 

  7. }
    8. 

  8. process = Runtime.getRuntime().exec(commands);
    9. 





好了，今天介绍到这里。
上一篇：python调用shell脚本时需要切换目录

下一篇：Java -- 找不到或无法加载主类