Java执行shell遇到的各种问题

1、判断子进程是否执行结束

有的时候我们用java调用shell之后，之后的操作要在Process子进程正常执行结束的情况下才可以继续，所以我们需要判断Process进程什么时候终止。

Process类提供了waitFor()方法。该方法导致当前线程等待，直到Process线程终止。

Process.waitFor()是有一个int类型返回值的，当返回值为0的时候表Process进程正常终止。否则一般是脚本执行出错了（我遇到的一般是这种情况）。

2、Process.waitFor()导致当前线程阻塞。

有的时候我们发现调用waitFor（）方法后，java主线程会一直阻塞在waitFor（）处，阻塞的原因是什么呢？分析一下：

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

向标准输出流和标准错误流写数据，而JVM却不读取，数据会暂存在linux缓存区，当缓存区存满之后导致该进程无法继续写数据，会僵死，导致java进程会卡死在waitFor()处，

永远无法结束。

解决办法：java进程在waitFor()前不断读取标准输出流和标准错误流：

1. //jyName  解压脚本路径
2. String fileName=fileList.get(0).toString().substring(fileList.get(0).toString().lastIndexOf(File.separator)+1);
3. String  jyName="/etc/zxvf.sh "+fileName;
4. try {
5. Process p0 = Runtime.getRuntime().exec(jyName);
6. //读取标准输出流
7. BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(p0.getInputStream()));
8. String line;
9. while ((line=bufferedReader.readLine()) != null) {
10. System.out.println(line);
11. }
12. //读取标准错误流
13. BufferedReader brError = new BufferedReader(new InputStreamReader(p0.getErrorStream(), "gb2312"));
14. String errline = null;
15. while ((errline = brError.readLine()) != null) {
16. System.out.println(errline);
17. }
18. //waitFor()判断Process进程是否终止，通过返回值判断是否正常终止。0代表正常终止
19. int c=p0.waitFor();
20. if(c!=0){
21. baseRes.put("desc", "软件升级失败：执行zxvf.sh异常终止");
22. baseRes.setReturnFlag(false);
23. return baseRes;
24. }
25. } catch (IOException e1) {
26. baseRes.put("desc", "软件升级失败：文件解压失败");
27. baseRes.setReturnFlag(false);
28. return baseRes;
29. } catch (InterruptedException e1) {
30. baseRes.put("desc", "软件升级失败：文件解压失败");
31. baseRes.setReturnFlag(false);
32. return baseRes;
33. }

也可以在执行Runtime.getRuntime().exec(jyName)之后另外再启动两个线程分别读取标准错误流和标准输出流

1. import java.io.BufferedReader;
2. import java.io.IOException;
3. import java.io.InputStream;
4. import java.io.InputStreamReader;
5. public class ExcuteThread extends Thread {
6. private String name;
7. public ExcuteThread(String name) {
8. this.name = name;
9. }
10. @Override
11. public void run() {
12. try {
13. Process p = Runtime.getRuntime().exec(name);
14. InputStream fis = p.getInputStream();
15. final BufferedReader brError = new BufferedReader(
16. new InputStreamReader(p.getErrorStream(), "gb2312"));
17. InputStreamReader isr = new InputStreamReader(fis, "gb2312");
18. final BufferedReader br = new BufferedReader(isr);
19. Thread t1 = new Thread() {
20. public void run() {
21. String line = null;
22. try {
23. while ((line = brError.readLine()) != null) {
24. // System.out.println(line);
25. }
26. } catch (IOException e) {
27. e.printStackTrace();
28. } finally {
29. try {
30. if (brError != null)
31. brError.close();
32. } catch (IOException e) {
33. e.printStackTrace();
34. }
35. }
36. }
37. };
38. Thread t2 = new Thread() {
39. public void run() {
40. String line = null;
41. try {
42. while ((line = br.readLine()) != null) {
43. // System.out.println(line);
44. }
45. } catch (IOException e) {
46. e.printStackTrace();
47. } finally {
48. try {
49. if (br != null)
50. br.close();
51. } catch (IOException e) {
52. // TODO Auto-generated catch block
53. e.printStackTrace();
54. }
55. }
56. }
57. };
58. t1.start();
59. t2.start();
60. } catch (IOException e1) {
61. // TODO Auto-generated catch block
62. e1.printStackTrace();
63. } finally {
64. }
65. }
66. }

3、shell脚本中有关联脚本，注意路径

就是shell脚本中还要执行其他脚本，这时候就是注意一个路径的问题，这个问题也是我找了好长时间的一个问题。

Process p=Runtime.getRuntime().exec(“/etc/a.sh”)

在Test.java类调用了etc目录下的a.sh脚本， a.sh脚本中执行etc目录下的b.sh脚本，原来我在a.sh脚本中写的是./b.sh。其实这样linux是找不到b.sh的，因为我们执行是在

Test.class目录下调用的/etc/a.sh  所以当a.sh中执行./b.sh的时候他会在Test.class目录下寻找，所以找不到，所以a.sh中要写成/etc/b.sh

4、java连续调用多个脚本

1. String[] cmd = { "/bin/sh", "-c", "rm -rf /installation/upgrade/ ; mkdir /installation/upgrade/" };
2. Process p = Runtime.getRuntime().exec(cmd);
3. p.waitFor();

就是这种数组的方式。

5、java执行.sh脚本文件的时候直接写目录就行，例如这样：Runtime.getRuntime().exec(“/etc/a.sh”)

java 直接执行语句的时候需要加上"/bin/sh"  例如这样：

1. String name="/bin/sh cd /installation/upgrade/ip89_install_packet";
2. Process p = Runtime.getRuntime().exec(name);