Java 调用 shell 脚本详解

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

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

大家且听我一一道来。

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

[java] view plain copy

  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

[plain] view plain copy

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

输出结果为：

[plain] view plain copy

  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脚本的子进程卡死，这两种输出需要分别读取，而且不能互相影响。所以必须新开两个线程来进行读取。

我开始的实现如下：

[java] view plain copy

  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. }

[java] view plain copy

  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卡死的情况。

[plain] view plain copy

  1. #!/bin/bash
  2. while true;do
  3. a=1
  4. sleep 0.1
  5. done

[java] view plain copy

  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. }

[java] view plain copy

  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. }

[java] view plain copy

  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()描述，这个方法是非阻塞的。


[java] view plain copy



    

  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方法有特别的注意事项。


[java] view plain copy



    

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

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



等价于


[java] view plain copy



    

  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. 



好了，今天介绍到这里。



原文地址：https://www.cnblogs.com/hyl8218/p/8302552.html
				


				
时间： 2024-10-14 00:59:01 

		


		


	

	
	

		


		
Java 调用 shell 脚本详解的相关文章


								

		

			

                JAVA调用Shell脚本
			

		

		

									

				在实际项目中,Java有时候需要调用C写出来的东西,除了JNI以外,我认为一种比较好的方法是JAVA调用Shell.先把C写出来的make成可执行文件,然后再写一个shell脚本执行该可执行文件,最后是JAVA调用该shell脚本. JAVA调用很简单,例子如下: 首先是shell脚本 [plain] view plain copy print? #!/bin/sh echo Begin word cluster /home/felven/word2vec/word2vec -train /ho			

		

	

				

		

			

                java调用shell脚本且传递参数
			

		

		

									

				在最近的工作中,需要用到Java要调用shell脚本的情况.总结如下: @RequestMapping("/changePermission") public String changePermission(){ String returnCode = ""; try { Process process = Runtime.getRuntime().exec("chmod 755 /tmp/upgrade.sh"); process.waitFo			

		

	

				

		

			

                java调用shell脚本,并获得结果集的例子
			

		

		

									

				/** * 运行shell脚本 * @param shell 需要运行的shell脚本 */ public static void execShell(String shell){ try { Runtime rt = Runtime.getRuntime(); rt.exec(shell); } catch (Exception e) { e.printStackTrace(); } } /** * 运行shell * * @param shStr * 需要执行的shell * @return			

		

	

				

		

			

                java调用shell脚本，并且返回结果集
			

		

		

									

				1 /** 2 * 运行shell脚本 3 * @param shell 需要运行的shell脚本 4 */ 5 public static void execShell(String shell){ 6 try { 7 Runtime rt = Runtime.getRuntime(); 8 rt.exec(shell); 9 } catch (Exception e) { 10 e.printStackTrace(); 11 } 12 } 13 14 15 /** 16 * 运行shell			

		

	

				

		

			

                Java调用 shell脚本阻塞
			

		

		

									

				Java在调用Shell时,要不断读取进程中标准输出和错误输出流的信息,否则缓冲区被写满就会造成子进程阻塞而无法继续运行下去,可起两个线程不断读取标准输出.错误流信息而不被阻塞 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.UnsupportedEncodingExcept			

		

	

				

		

			

                Java代码调用Shell脚本并传入参数实现DB2数据库表导出到文件
			

		

		

									

				本文通过Java代码调用Shell脚本并传入参数实现DB2数据库表导出到文件,代码如下: import java.io.File; import java.io.IOException; import java.io.InputStreamReader; import java.io.LineNumberReader; import java.util.HashMap; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import			

		

	

				

		

			

                Java调用Shell命令和脚本
			

		

		

									

				1.介绍 有时候我们在Linux中运行Java程序时,需要调用一些Shell命令和脚本.而Runtime.getRuntime().exec()方法给我们提供了这个功能,而且Runtime.getRuntime()给我们提供了以下几种exec()方法: Process exec(String command) 在单独的进程中执行指定的字符串命令. Process exec(String[] cmdarray) 在单独的进程中执行指定命令和变量. Process exec(String[] cmd			

		

	

				

		

			

                java 通过jni调用c++实现详解
			

		

		

									

				Java通过JNI调用C++程序 JNI是Java Native Interface的缩写,中文为JAVA本地调用.使用JNI可以很方便的用我们的Java程序调用C/C++程序.很多时候,某些功能用Java无法实现,比如说涉及到底层驱动的一些功能,这时候我们就可以利用JNI来调用C或者C++程序来实现,这就是JNI的强大之处.但是JNI也有它的缺点,使用java与本地已编译的代码交互,通常会丧失平台可移植性. 下面是一个JNI例子,调用C++输出"hello world": 第一步:创			

		

	

				

		

			

                Java执行shell脚本关闭远程数据库
			

		

		

									

				本实例为用Java执行shell脚本启动或关闭远程Mysql数据库,需求原因:游戏服务器合服后,为了节省内存消耗,需要关闭合服后的服务器不必要的数据库(一台服务器主机存在多个MySql数据库),以提高服务器性能,但有时需要查询历史游戏玩家信息,又需要开启数据库,为了节省运维人员的人力和时间,游戏后台就提供非运维人员都可操作开关数据库的操作. 功能实现步骤: 第一:服务器后台提供参数,发送异步请求,请求方法如下 <script type="text/javascript">