package someTest;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class ShellTest {
 
    public static void main(String[] args) {
        InputStreamReader stdISR = null;
        InputStreamReader errISR = null;
        Process process = null;
        String command = "/home/Lance/workspace/someTest/testbash.sh";
        try {
            process = Runtime.getRuntime().exec(command);
            int exitValue = process.waitFor();
 
            String line = null;
 
            stdISR = new InputStreamReader(process.getInputStream());
            BufferedReader stdBR = new BufferedReader(stdISR);
            while ((line = stdBR.readLine()) != null) {
                System.out.println("STD line:" + line);
            }
 
            errISR = new InputStreamReader(process.getErrorStream());
            BufferedReader errBR = new BufferedReader(errISR);
            while ((line = errBR.readLine()) != null) {
                System.out.println("ERR line:" + line);
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            try {
                if (stdISR != null) {
                    stdISR.close();
                }
                if (errISR != null) {
                    errISR.close();
                }
                if (process != null) {
                    process.destroy();
                }
            } catch (IOException e) {
                System.out.println("正式执行命令:" + command + "有IO异常");
            }
        }
    }
}

testbash.sh

#!/bin/bash

echo pwd

输出结果为:

 

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

 

我开始的实现如下:

 

package someTest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.List;

public class CommandStreamGobbler extends Thread {

private InputStream is;

private String command;

private String prefix = "";

private boolean readFinish = false;

private boolean ready = false;

private List<String> infoList = new LinkedList<String>();

CommandStreamGobbler(InputStream is, String command, String prefix) {
this.is = is;
this.command = command;
this.prefix = prefix;
}

public void run() {
InputStreamReader isr = null;
try {
isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line = null;
ready = true;
while ((line = br.readLine()) != null) {
infoList.add(line);
System.out.println(prefix + " line: " + line);
}
} catch (IOException ioe) {
System.out.println("正式执行命令:" + command + "有IO异常");
} finally {
try {
if (isr != null) {
isr.close();
}
} catch (IOException ioe) {
System.out.println("正式执行命令:" + command + "有IO异常");
}
readFinish = true;
}
}

public InputStream getIs() {
return is;
}

public String getCommand() {
return command;
}

public boolean isReadFinish() {
return readFinish;
}

public boolean isReady() {
return ready;
}

public List<String> getInfoList() {
return infoList;
}
}
package someTest;

import java.io.IOException;
import java.io.InputStreamReader;

public class ShellTest {

public static void main(String[] args) {
InputStreamReader stdISR = null;
InputStreamReader errISR = null;
Process process = null;
String command = "/home/Lance/workspace/someTest/testbash.sh";
try {
process = Runtime.getRuntime().exec(command);

CommandStreamGobbler errorGobbler = new CommandStreamGobbler(process.getErrorStream(), command, "ERR");
CommandStreamGobbler outputGobbler = new CommandStreamGobbler(process.getInputStream(), command, "STD");

errorGobbler.start();
// 必须先等待错误输出ready再建立标准输出
while (!errorGobbler.isReady()) {
Thread.sleep(10);
}
outputGobbler.start();
while (!outputGobbler.isReady()) {
Thread.sleep(10);
}

int exitValue = process.waitFor();
} catch (IOException | InterruptedException e) {
e.printStackTrace();
} finally {
try {
if (stdISR != null) {
stdISR.close();
}
if (errISR != null) {
errISR.close();
}
if (process != null) {
process.destroy();
}
} catch (IOException e) {
System.out.println("正式执行命令:" + command + "有IO异常");
}
}
}
}

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

 

 

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

 

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

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

 

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

#!/bin/bash

while true;do
a=1
sleep 0.1
done
package someTest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.List;

public class CommandStreamGobbler extends Thread {

private InputStream is;

private String command;

private String prefix = "";

private boolean readFinish = false;

private boolean ready = false;

      // 命令执行结果,0:执行中 1:超时 2:执行完成
      private int commandResult = 0;

private List<String> infoList = new LinkedList<String>();

CommandStreamGobbler(InputStream is, String command, String prefix) {
this.is = is;
this.command = command;
this.prefix = prefix;
}

public void run() {
InputStreamReader isr = null;
BufferedReader br = null;
try {
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
String line = null;
ready = true;
while (commandResult != 1) {
if (br.ready() || commandResult == 2) {
                                  if ((line = br.readLine()) != null) {
                                      infoList.add(line);
                                  } else {
                                      break;
                                  }
                              } else {
                                  Thread.sleep(100);
                              }
}
} catch (IOException | InterruptedException ioe) {
System.out.println("正式执行命令:" + command + "有IO异常");
} finally {
try {
if (br != null) {
br.close();
}
if (isr != null) {
isr.close();
}
} catch (IOException ioe) {
System.out.println("正式执行命令:" + command + "有IO异常");
}
readFinish = true;
}
}

public InputStream getIs() {
return is;
}

public String getCommand() {
return command;
}

public boolean isReadFinish() {
return readFinish;
}

public boolean isReady() {
return ready;
}

public List<String> getInfoList() {
return infoList;
}

public void setTimeout(int timeout) {
this.commandResult = timeout;
}
}
package someTest;

public class CommandWaitForThread extends Thread {

private Process process;
private boolean finish = false;
private int exitValue = -1;

public CommandWaitForThread(Process process) {
this.process = process;
}

public void run() {
try {
this.exitValue = process.waitFor();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
finish = true;
}
}

public boolean isFinish() {
return finish;
}

public void setFinish(boolean finish) {
this.finish = finish;
}

public int getExitValue() {
return exitValue;
}

}
package someTest;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Date;

public class ShellTest {

public static void main(String[] args) {
InputStreamReader stdISR = null;
InputStreamReader errISR = null;
Process process = null;
String command = "/home/Lance/workspace/someTest/testbash.sh";
long timeout = 10 * 1000;
try {
process = Runtime.getRuntime().exec(command);

CommandStreamGobbler errorGobbler = new CommandStreamGobbler(process.getErrorStream(), command, "ERR");
CommandStreamGobbler outputGobbler = new CommandStreamGobbler(process.getInputStream(), command, "STD");

errorGobbler.start();
// 必须先等待错误输出ready再建立标准输出
while (!errorGobbler.isReady()) {
Thread.sleep(10);
}
outputGobbler.start();
while (!outputGobbler.isReady()) {
Thread.sleep(10);
}

CommandWaitForThread commandThread = new CommandWaitForThread(process);
commandThread.start();

long commandTime = new Date().getTime();
long nowTime = new Date().getTime();
boolean timeoutFlag = false;
while (!commandIsFinish(commandThread, errorGobbler, outputGobbler)) {
if (nowTime - commandTime > timeout) {
timeoutFlag = true;
break;
} else {
Thread.sleep(100);
nowTime = new Date().getTime();
}
}
if (timeoutFlag) {
// 命令超时
errorGobbler.setTimeout(1);
outputGobbler.setTimeout(1);
System.out.println("正式执行命令:" + command + "超时");
}else {
// 命令执行完成
errorGobbler.setTimeout(2);
outputGobbler.setTimeout(2);
                      }

while (true) {
if (errorGobbler.isReadFinish() && outputGobbler.isReadFinish()) {
break;
}
Thread.sleep(10);
}
} catch (IOException | InterruptedException e) {
e.printStackTrace();
} finally {
if (process != null) {
process.destroy();
}
}
      }

private boolean commandIsFinish(CommandWaitForThread commandThread, CommandStreamGobbler errorGobbler, CommandStreamGobbler outputGobbler) {
if (commandThread != null) {
return commandThread.isFinish();
} else {
return (errorGobbler.isReadFinish() && outputGobbler.isReadFinish());
}
}
}

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

 

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

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

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.

Returns:
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.

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

 

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

 

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

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

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

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

等价于

List<String> commandList = new LinkedList<String>();
commandList.add("/home/Lance/workspace/someTest/testbash.sh");
commandList.add("hello world");
String[] commands = new String[commandList.size()];
for (int i = 0; i < commandList.size(); i++) {
commands[i] = commandList.get(i);
}

process = Runtime.getRuntime().exec(commands);
 
版权声明:本文为root-123原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/root-123/p/16574701.html