如何在C语言中调用shell命令

C语言中调用shell指令，根据调用指令目的，可以区分如下两种情况：

一、需要shell指令执行某一功能，如创建文件夹，或者删除文件夹等，程序中不关注shell指令的输出，那么可以使用system函数。

system函数声明于stdlib.h， 功能为调用系统命令，形式为

int system(const char *cmd)

其中cmd为要执行的命令字符串，返回值为执行是否成功的标记。

比如在Linux下要删除当前文件夹下的所有扩展名为a的文件，即*.a， 可以写作

system("rm *.a -f")

二、不仅要执行shell命令，还需要得知运行的打印结果，并在程序中使用。

对于此，有两种方案：

1、用system命令，将输出重定向到一个txt文件中，执行后，再读取txt文件，使用后删除。

比如Linux下获取剩余内存的指令可以写作：

system("free>result.txt")//结果重定向到result.txt中。

FILE *fp = fopen("result.txt", "r")//打开文件。

int r

while(fgetc(fp) != '\n') //忽略第一行。

fscanf(fp, "%*s%*d%*d%d",&r)//读取第四个域的值，即剩余内存值。

printf("剩余内存为%d KB\n",r)//打印结果。

fclose(fp)//关闭文件。

unlink("result.txt")//删除临时文件。

2、使用重定向，需要经过磁盘读写，还要删除文件，相对低效。同时还有可能出现临时文件和已有文件重名，导致误删数据的情况。 所以一般使用更方便快捷的方式，即调用popen。

FILE *popen(const char *cmd, const char *mode)

使用popen的功能和system类似，属于方法1中执行命令和打开文件的一个组合。不过这里用到的文件是隐式的，并不会在系统中真正存在。返回的指针即结果文件指针。 当使用pclose关闭后，文件自动销毁。

方法1中的例子，用popen实现如下：

FILE *fp = popen("free", "r")//执行命令，同时创建管道文件。

int r

while(fgetc(fp) != '\n') //忽略第一行。

fscanf(fp, "%*s%*d%*d%d",&r)//读取第四个域的值，即剩余内存值。

printf("剩余内存为%d KB\n",r)//打印结果。

pclose(fp)//关闭并销毁管道文件。

三、注意事项：

虽然调用shell命令有时可以大大减少代码量，甚至有千行坦则正代码不如一句shell的说法，不过调用shell命令还是有局限性的：

1、使用shell命令会调用盯陆系统资源，效率偏低；

2、不同平台的shell指令不同，导致可移植性下让悔降；

3、调用shell命令时会复制当前进程(fork)，如果当前进程的资源占有比较大，会导致瞬间资源占用极大，甚至可能出现失败。

所以，在编码时，除非是测试性的代码，否则在正式代码中不建议使用shell。

题主可以使用 exec 系列函数。这系列函数定穗数纤义在 unistd.h 头文件中，所以使用前请包含这个头文件。这系列函数共有五个，

execl, execlp, execv, execvp, execle

其中常用的是前四个。前四个函数的原型为：

int execl(const char *path, const char *arg, ...)

int execlp(const char *file, const char *arg, ...)

int execv(const char *path, char *const argv[])

int execvp(const char *file, char *const argv[])

这四个函数的主要差别就在于参数的类型和用不用输入命令的绝对路径上。

以路径形式来分，凡是函数名中带 p 的（execlp，execvp）都只需要提供命令的名，函数会自动在当前的环境变量 $PATH 中查找命令的路径。而不带 p 的（execl，execv）必须要提供命令的绝对路径，否则函数会找不到这个命令的位置。这里以 execl 和 execlp 为例，以下运行

ls -l

命令的代码：

#include <stdio.h>

#include <unistd.h>

int main() {

    // exec 系列函数出错时会返回 -1，平常返回 0，所以可以

    // 据此来打印错误信息

    // 第一个 ls 是命令的名称，execlp 函数会自动在 $PATH

    // 中寻找这个命令。

    // 后面一个 ls 是要在 shell 中输入的第一个参数

    //（也就是命令名称本身）

    // 使用 NULL 作为参数结尾标记是 exec 系列函数的要求。

    if (execlp("ls", "ls", "-l", NULL) == -1)

        perror("Error Executing Command.\n")

    return 0

    

}

在 shell 中运行这个 C 程序会输出

和你直接在 shell 中写 ls -l 的效果是一样的。然而，如果你使用不带 p 的 execl， 那么这样写就会报错。

#include <stdio.h>

#include <unistd.h>

int main() {

    // execl 只接受命令的绝对路径，所以必须输入完整的

    // 路径 /bin/ls，即

    // if (execl("/bin/ls", "ls", "-l", NULL) == -1)

    if (execl("ls", "ls", "-l", NULL) == -1)

        perror("Error Executing Command.\n")

    return 0

    

}

输出结果为：

以参数类型来分，凡是函数名中带 l 的（execl，execlp）都需要把系统命令的参数全部传递给函数，而凡是函数名中带 v 的（execv，execvp）都需要把系统命令的参数统一放在一个数组里，然后把这个数组传递给函数。

比如刚才这个

#include <stdio.h>

#include <unistd.h>

int main() {

    if (execlp("ls", "ls", "-l", NULL) == -1)

        perror("Error Executing Command.\n")

    return 0

    

}

如果改用 execvp 来写的话就是

#include <stdio.h>

#include <unistd.h>

int main() {

    // 这个字符串数组存有所有参数（包括命令名本身和

  猜仿  // 最后的 NULL）

    char * argv[] = {"ls", "-l", NULL}

    

    // 这里只需将命令名称和参数数组传递给 execvp 函数即可，

    // 无需将参数一个个传递。同样函数会自动在 $PATH 

    // 中查找命令

    if (execvp("ls", argv) == -1)

        perror("Error Executing Command.\n")

    return 0

    

}

运行结果同样和直接写 ls -l 的效果相同。

execv 和 execvp 的区别也在于是否必须输入绝对路径，就不赘述了。

要注意的一点是，如果执行成功，exec 系列函数开启的新进程会完全代替当前的进程，也就是说当前进程会消失。所以一般会将 exec 和 fork 连用，先 fork 出一个子进程，然后在毕埋这个子进程中使用 exec 运行别的程序，防止父进程被 exec 覆盖。比如刚才的代码稍微改一下

#include <stdio.h>

#include <unistd.h>

int main() {

    char * argv[] = {"ls", "-l", NULL}

    if (execvp("ls", argv) == -1)

        perror("Error Executing Command.\n")

        

    // 加入一个 printf 语句

    printf("Main process is still running.\n")

    return 0

    

}

运行后并不会出现 Main process is still running 这句话，因为 exec 后 main 函数执行产生的进程已经被 ls 命令产生的进程完全覆盖了，所以 exec 函数以下的语句是完全不会执行的。这时就可以使用 fork 来新建一个子进程，在子进程中执行 exec 函数。

#include <stdio.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

int main() {

    

    int r

    

    // fork() 大于零，父进程

    if ((r = fork()) > 0) {

        int status

        if (wait(&status) != -1) {

            

            // 等待子进程退出

            if(WIFEXITED(status)) {

                printf("Main process is still running.\n")

                return 0

            }

        }

    

    // fork () 等于零，子进程。子进程中运行 exec    

    } else if (r == 0) {

    

        char * argv[] = {"ls", "-l", NULL}

        if (execvp("ls", argv) == -1)

            perror("Error Executing Command.\n")

        return 0

    

    // fork() 小于零，出错

    } else {

        perror("Fork")

    }

    

    return 0

    

}

这样运行结果就变成了

Main process is still running 这句话就会被输出到屏幕上。

怎样在java代码中调用执行shell脚本

// 用法：Runtime.getRuntime.exec("命令")

String shpath="/test/test.sh"   //程序路径

Process process =null

String mand1 = “chmod 777 ” + shpath

try {

Runtime.getRuntime.exec(mand1 ).waitFor

} catch (IOException e1) {

e1.printStackTrace

}catch (InterruptedException e) {

e.printStackTrace

}

String var="201102"  /参数

String mand2 = “/bin/sh ” + shpath + ” ” + var

Runtime.getRuntime.exec(mand2).waitFor

如何在java中执行shell脚本

// 用法：Runtime.getRuntime.exec("命令")

String shpath="/test/test.sh"//程序路径

Process process =null

String mand1 = “chmod 777 ” + shpath

try {

Runtime.getRuntime.exec(mand1 ).waitFor

} catch (IOException e1) {

e1.printStackTrace

}catch (InterruptedException e) {

e.printStackTrace

}

String var="201102"/参数

String mand2 = “/bin/sh ” + shpath + ” ” + var

Runtime.getRuntime.exec(mand2).waitFor

java怎么调用shell脚本

String cmdstring = "chmod a+x test.sh"

Process proc = Runtime.getRuntime.exec(cmdstring)

proc.waitFor //阻塞，直到上述命令执行完

cmdstring = "bash test.sh" //这里也可以是ksh等

proc = Runtime.getRuntime.exec(cmdstring)

// 注意下面的 *** 作

string ls_1

BufferedReader bufferedReader = new BufferedReader( new InputStreamReader(proc.getInputStream)

while 祥配铅( (ls_1=bufferedReader.readLine) != null)

bufferedReader.close

proc.waitFor

为什谨好么要有上面那段 *** 作呢？

原因是：可执行程序的输出可能会比较多，而运行窗口的输出缓冲区有限，会造成waitFor一直阻塞。解决的办法是，利用Java提供的Process类提供的getInputStream,getErrorStream方法让Java虚拟机截获被调用程序的标准输出、错误输出，在waitfor命令之前读掉输出缓冲区中的内容。

如何在java中执行shell脚本

在java中执行shell脚本 用卖碧法：Runtime.getRuntime.exec("命令")

String shpath="/test/test.sh"//程序路径

Process process =null

String mand1 = “chmod 777 ” + shpath

try {

Runtime.getRuntime.exec(mand1 ).waitFor

} catch (IOException e1) {

e1.printStackTrace

}catch (InterruptedException e) {

e.printStackTrace

}

String var="201102"/参数

String mand2 = “/bin/sh ” + shpath + ” ” + var

Runtime.getRuntime.exec(mand2).waitFor

标签：作文经典 上一篇：一个人带头的成语 一个猪头带头的成语 下一篇：描写长城的语句 描写长城美景的语句

怎么通过java去调用并执行shell脚本以及问题总结

以下是我在公司项目中实际应用到的：

/**

* 执行系统命令

* @time 2016/10/17$ 17:05$

*/

public final class SystemmandExecutor {

protected static Logger logger = LoggerFactory.getLogger(ShareDiskFileUtils.class)

public static final boolean isWindow

public static final boolean isLinux

static {

String osname = System.getProperty("os.name").toLowerCase

isWindow = osname.contains("win")

isLinux = osname.contains("linux")

logger.info("系统环境： " + (isLinux ? "Linux" : "Window"))

}

/**

* 执行命令

*/

public static Process executemand(String mand) throws IOException, InterruptedException {

logger.info("执行系统命令： " + mand)

Process process = Runtime.getRuntime.exec(getCmdArray(mand))

new StreamPrinter(process.getInputStream, logger).start

new StreamPrinter(process.getErrorStream, logger).start

process.waitFor

return process

}

/**

* 这个非常重要， 如果你直接执行mand，会出现一些问题，如果参数中包含一些空格，", ' 之类的特殊字符，将会执行失败，

*/

private static String[] getCmdArray(String mand) {

if (isWindow) {

return new String[]{"cmd", "/c", mand}

}

if (isLinux) {

return new String[]{"/bin/sh", "-c", mand}

}

return new String[]{"cmd", "/c", mand}

}

}

怎么通过java去调用并执行shell脚本以及问题总结

// 用法：Runtime.getRuntime.exec("命令")

String shpath="/test/test.sh"//程序路径

Process process =null

String mand1 = “chmod 777 ” + shpath

try {

Runtime.getRuntime.exec(mand1 ).waitFor

} catch (IOException e1) {

e1.printStackTrace

}catch (InterruptedException e) {

e.printStackTrace

}

String var="201102"/参数

String mand2 = “/bin/sh ” + shpath + ” ” + var

Runtime.getRuntime.exec(mand2).waitFor

java怎么执行shell脚本

如果shell脚本和java程序运行在不同的服务器上，可以使用远程执行Linux命令执行包，使用ssh2协议连接远程服务器，并发送执行命令就行了，ganymed.ssh2相关mave配置如下，你可以自己百度搜索相关资料。

如果shell脚本和java程序在同一台服务器上，

这里不得不提到java的process类了。

process这个类是一个抽象类，封装了一个进程（你在调用linux的命令或者shell脚本就是为了执行一个在linux下执行的程序，所以应该使用process类）。

process类提供了执行从进程输入，执行输出到进程，等待进程完成，检查进程的推出状态，以及shut down掉进程。

.ganymed.ssh2

ganymed-ssh2-build

210

本地执行命令代码如下：

String shpath="/test/test.sh"   //程序路径

Process process =null

String mand1 = “chmod 777 ” + shpath

process = Runtime.getRuntime.exec(mand1)

process.waitFor

如何在java中执行shell脚本

1、最常用的方法：

Process p = Runtime.getRuntime.exec(SHELL_FILE_DIR + RUNNING_SHELL_FILE +

" "+param1+" "+param2+" "+param3)

int runnngStatus = p.waitFor

2、通过ProcessBuilder进行调度，这种方法比较直观，而且参数的设置也比较方便：

ProcessBuilder pb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, param1,

param2, param3)

pb.directory(new File(SHELL_FILE_DIR))

int runningStatus = 0

String s = null

try {

Process p = pb.start

try {

runningStatus = p.waitFor

} catch (InterruptedException e) {

e.printStackTrace

}

} catch (IOException e) {

e.printStackTrace

}

if (runningStatus != 0) {

}

return

参数说明：

RUNNING_SHELL_FILE：要运行的脚本

SHELL_FILE_DIR：要运行的脚本所在的目录； 当然你也可以把要运行的脚本写成全路径。

runningStatus：运行状态，0标识正常。 详细可以看java文档。

param1, param2, param3：可以在RUNNING_SHELL_FILE脚本中直接通过1,1,2,$3分别拿到的参数。

怎么通过java去调用并执行shell脚本以及问题总结

对于第一个问题：java抓取，并且把结果打包。那么比较直接的做法就是，java接收各种消息（db，metaq等等），然后借助于jstorm集群进行调度和抓取。

最后把抓取的结果保存到一个文件中，并且通过调用shell打包， 回传。 也许有同学会问，

为什么不直接把java调用odps直接保存文件，答案是，我们的集群不是hz集群，直接上传odps速度很有问题，因此先打包比较合适。（这里不纠结设计了，我们回到正题）

java调用shell的方法

通过ProcessBuilder进行调度

这种方法比较直观，而且参数的设置也比较方便， 比如我在实践中的代码(我隐藏了部分业务代码)：

ProcessBuilderpb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, param1,

param2, param3)

pb.directory(new File(SHELL_FILE_DIR))

int runningStatus = 0

String s = null

try {

Process p = pb.start

try {

runningStatus = p.waitFor

} catch (InterruptedException e) {

}

} catch (IOException e) {

}

if (runningStatus != 0) {

}

return

这里有必要解释一下几个参数：

RUNNING_SHELL_FILE：要运行的脚本

SHELL_FILE_DIR：要运行的脚本所在的目录； 当然你也可以把要运行的脚本写成全路径。

runningStatus：运行状态，0标识正常。 详细可以看java文档。

param1, param2, param3：可以在RUNNING_SHELL_FILE脚本中直接通过1,2,$3分别拿到的参数。

直接通过系统Runtime执行shell

这个方法比较暴力，也比较常用， 代码如下：

p = Runtime.getRuntime.exec(SHELL_FILE_DIR + RUNNING_SHELL_FILE + " "+param1+" "+param2+" "+param3)

p.waitFor

我们发现，通过Runtime的方式并没有builder那么方便，特别是参数方面，必须自己加空格分开，因为exec会把整个字符串作为shell运行。

可能存在的问题以及解决方法

如果你觉得通过上面就能满足你的需求，那么可能是要碰壁了。你会遇到以下情况。

没权限运行

这个情况我们团队的朱东方就遇到了， 在做DTS迁移的过程中，要执行包里面的shell脚本， 解压出来了之后，发现执行不了。 那么就按照上面的方法授权吧

java进行一直等待shell返回

这个问题估计更加经常遇到。 原因是， shell脚本中有echo或者print输出， 导致缓冲区被用完了! 为了避免这种情况， 一定要把缓冲区读一下， 好处就是，可以对shell的具体运行状态进行log出来。 比如上面我的例子中我会变成：

ProcessBuilderpb = new ProcessBuilder("./" + RUNNING_SHELL_FILE, keyword.trim,

taskId.toString, fileName)

pb.directory(new File(CASPERJS_FILE_DIR))

int runningStatus = 0

String s = null

try {

Process p = pb.start

BufferedReaderstdInput = new BufferedReader(new InputStreamReader(p.getInputStream))

BufferedReaderstdError = new BufferedReader(new InputStreamReader(p.getErrorStream))

while ((s = stdInput.readLine) != null) {

LOG.error(s)

}

while ((s = stdError.readLine) != null) {

LOG.error(s)

}

try {

runningStatus = p.waitFor

} catch (InterruptedException e) {

}

记得在start之后， waitFor（）之前把缓冲区读出来打log， 就可以看到你的shell为什么会没有按照预期运行。 这个还有一个好处是，可以读shell里面输出的结果， 方便java代码进一步 *** 作。

也许你还会遇到这个问题，明明手工可以运行的命令，java调用的shell中某一些命令居然不能执行，报错：命令不存在！

比如我在使用casperjs的时候，手工去执行shell明明是可以执行的，但是java调用的时候，发现总是出错。

通过读取缓冲区就能发现错误日志了。 我发现即便自己把安装的casperjs的bin已经加入了path中（/etc/profile,

各种bashrc中）还不够。 比如：

exportNODE_HOME="/home/admin/node"

exportCASPERJS_HOME="/home/admin/casperjs"

exportPHANTOMJS_HOME="/home/admin/phantomjs"

exportPATH=$PATH:$JAVA_HOME/bin:/root/bin:$NODE_HOME/bin:$CASPERJS_HOME/bin:$PHANTOMJS_HOME/bin

原来是因为java在调用shell的时候，默认用的是系统的/bin/下的指令。特别是你用root权限运行的时候。 这时候，你要在/bin下加软链了。针对我上面的例子，就要在/bin下加软链：

ln -s /home/admin/casperjs/bin/casperjscasperjs

ln -s /home/admin/node/bin/nodenode

ln -s /home/admin/phantomjs/bin/phantomjsphantomjs

这样，问题就可以解决了。

如果是通过java调用shell进行打包，那么要注意路径的问题了

因为shell里面tar的压缩和解压可不能直接写：

tar -zcf /home/admin/data/result.tar.gz /home/admin/data/result

直接给你报错，因为tar的压缩源必须到路径下面， 因此可以写成

tar -zcf /home/admin/data/result.tar.gz -C /home/admin/data/ result

如果我的shell是在jar包中怎么办？

答案是：解压出来。再按照上面指示进行 *** 作。（1）找到路径

String jarPath = findClassJarPath(ClassLoaderUtil.class)

JarFiletopLevelJarFile = null

try {

topLevelJarFile = new JarFile(jarPath)

Enumeration entries = topLevelJarFile.entries

while (entries.hasMoreElements) {

JarEntryentry = entries.nextElement

if (!entry.isDirectory entry.getName.endsWith(".sh")) {

对你的shell文件进行处理

}

}

对文件处理的方法就简单了，直接touch一个临时文件，然后把数据流写入，代码：

FileUtils.touch(tempjline)

tempjline.deleteOnExit

FileOutputStreamfos = new FileOutputStream(tempjline)

IOUtils.copy(ClassLoaderUtil.class.getResourceAsStream(r), fos)

fos.close

如何在java中执行shell脚本

首先你可以百度搜一下 java Process 类的用法，很多博文都有讲解。

另外我补充一下我再使用过程中的一些点：

process = Runtime.getRuntime.exec(new String[]{"/bin/sh","-c",shellContext})

其中 shellContext 是shel脚本字符串

这句提交的时候，不少博文 exec中是直接提交shellContext。

但是对于一些场景不适用，取出来数据跟直接运行shell脚本有差异，可以改成我这种写法。

标签：作文经典 上一篇：一个人带头的成语 一个猪头带头的成语 下一篇：描写长城的语句 描写长城美景的语句

---