java运行linux命令获得返回值的问题

Posted 2023-05-08

我有java代码
String cmd = "ifconfig";
inputStream = Runtime.getRuntime().exec(cmd);
此时在linux下执行代码之后，这个inputStream里面是又内容的，我可以read到值。

问题是我把cmd改成一个获取视频时长的命令
("ffmpeg -i myVideoPath 2>&1 | grep 'Duration' | cut -d ' ' -f 4 | sed s/,//")
(需要装ffmpeg软件)并执行之后，inputStream是空的，什么都read不到。
但单独在linux控制台执行这段命令却明明会显示出视频时长。见图：

请问这是为什么？为什么在java中执行获取时长的命令就得到一个空的stream呢？
帮帮忙谢谢，

inputStream = Runtime.getRuntime().exec(cmd);

java的这个方式，得到的是控制台的输出流，
也就是linux命令运行完，显示在屏幕上的东西，都以流的方式传递给java了，

可以通过下边的方式
InputStreamReader insr = new InputStreamReader(inputStream, “GBK”);
BufferedReader br = new BufferedReader(insr);
while (br.ready())
String line = br.readLine();


得到屏幕上显示的一行行内容，解析得到你想要的结果。

InputStreamReader 最后一个参数，是设置显示流是什么字符集的，如果不正确，请自行调整一下。追问

打印出来的还是无内容。
inputStream都已经是无内容了，后面的封装肯定也没有效果

追答

首先在linux下执行你所需要的命令，确认有结果返回。

具体代码如下




public static String getShellExecuted(String cmnd) 

InputStream in = null;
InputStreamReader insr = null;
BufferedReader br = null;
StringBuffer buff = new StringBuffer();
try 
    Process process = Runtime.getRuntime().exec("sh /usr " + cmnd);
    process.waitFor();
    in = process.getInputStream();
    insr = new InputStreamReader(in, "GBK");
    br = new BufferedReader(insr);
    while (br.ready()) 
String line = br.readLine();
buff.append(line + "\\r\\n");
    
 catch (Exception e) 
 
return buff.toString();
    
这样你再试试。

参考技术A

因为有shell pipe。看这个例子：

String[] cmd = 
"/bin/sh",
"-c",
"ls /etc | grep release"
;

Process p = Runtime.getRuntime().exec(cmd);

追问

看不明白什么意思，麻烦能说详细一点么？我这个问题怎么解决呢？本人linux有点小白，

追答

就是 把 "ls /etc | grep release" 替换成你的 ”ffmpeg 。。。。。。。。“ 这串命令。

本回答被提问者采纳 参考技术B 管道命令是通过/bin/sh 解析的，java exec用的是系统exec函数族，所以就按照上面那个执行方法就好了

如何获得CreateProcess启动的进程返回的结果

参考技术A 怎么获得CreateProcess启动的进程返回的结果？
如题。
我在MFC工程里，使用CreateProcess启动了一个进程
要怎么获得这个进程返回的结果。

不是进程运行的状态，而是进程在运行的时候，会输出一些数据，我怎么在MFC工程里获得这些数据？

CreateProcess 结果
分享到：

------解决方案--------------------
输出到哪里的？
如果是输出到标准输出的，可以使用管道
------解决方案--------------------
_pipe
Creates a pipe for reading and writing.

int _pipe( int *phandles, unsigned int psize, int textmode );

Routine Required Header Optional Headers Compatibility
_pipe <io.h> <fcntl.h>,1 <errno.h>2 Win 95, Win NT

1 For _O_BINARY and _O_TEXT definitions.

2 errno definitions.

For additional compatibility information, see Compatibility in the Introduction.

Libraries

LIBC.LIB Single thread static library, retail version
LIBCMT.LIB Multithread static library, retail version
MSVCRT.LIB Import library for MSVCRT.DLL, retail version

Return Value

_pipe returns 0 if successful. It returns –1 to indicate an error, in which case errno is set to one of two values: EMFILE, which indicates no more file handles available, or ENFILE, which indicates a system file table overflow.

Parameters

phandles[2]

Array to hold read and write handles

psize

Amount of memory to reserve

textmode

File mode

Remarks

The _pipe function creates a pipe. A pipe is an artificial I/O channel that a program uses to pass information to other programs. A pipe is similar to a file in that it has a file pointer, a file descriptor, or both, and can be read from or written to using the standard library’s input and output functions. However, a pipe does not represent a specific file or device. Instead, it represents temporary storage in memory that is independent of the program’s own memory and is controlled entirely by the operating system.

_pipe is similar to _open but opens the pipe for reading and writing, returning two file handles instead of one. The program can use both sides of the pipe or close the one it does not need. For example, the command processor in Windows NT creates a pipe when executing a command such as

PROGRAM1
------解决方案--------------------
PROGRAM2

The standard output handle of PROGRAM1 is attached to the pipe’s write handle. The standard input handle of PROGRAM2 is attached to the pipe’s read handle. This eliminates the need for creating temporary files to pass information to other programs.

The _pipe function returns two handles to the pipe in the phandles argument. The element phandles[0] contains the read handle, and the element phandles[1] contains the write handle. Pipe file handles are used in the same way as other file handles. (The low-level input and output functions _read and _write can read from and write to a pipe.) To detect the end-of-pipe condition, check for a _read request that returns 0 as the number of bytes read.

The psize argument specifies the amount of memory, in bytes, to reserve for the pipe. The textmode argument specifies the translation mode for the pipe. The manifest constant _O_TEXT specifies a text translation, and the constant _O_BINARY specifies binary translation. (See fopen for a description of text and binary modes.) If the textmode argument is 0, _pipe uses the default translation mode specified by the default-mode variable _fmode.

In multithreaded programs, no locking is performed. The handles returned are newly opened and should not be referenced by any thread until after the _pipe call is complete.

In order to use the _pipe function to communicate between a parent and a child process, each process must have only one handle open on the pipe. The handles must be opposites: if the parent has a read handle open, then the child must have a write handle open. The easiest way to do this is to OR (
------解决方案--------------------
) the _O_NOINHERIT flag with textmode. Then, use _dup or _dup2 to create an inheritable copy of the pipe handle you wish to pass to the child. Close the original handle, and spawn the child process. Upon returning from the spawn call, close the 'duplicate' handle in the parent process. See Example 2 below for more information.

In Windows NT and Windows 95, a pipe is destroyed when all of its handles have been closed. (If all read handles on the pipe have been closed, writing to the pipe causes an error.) All read and write operations on the pipe wait until there is enough data or enough buffer space to complete the I/O request.

Example 1

/* PIPE.C: This program uses the _pipe function to pass streams of
* text to spawned processes.
*/

#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <process.h>
#include <math.h>

enum PIPES READ, WRITE ; /* Constants 0 and 1 for READ and WRITE */
#define NUMPROBLEM 8

void main( int argc, char *argv[] )


int hpipe[2];
char hstr[20];
int pid, problem, c;
int termstat;

/* If no arguments, this is the spawning process */
if( argc == 1 )


setvbuf( stdout, NULL, _IONBF, 0 );

/* Open a set of pipes */
if( _pipe( hpipe, 256, O_BINARY ) == -1 )
exit( 1 );

/* Convert pipe read handle to string and pass as argument
* to spawned program. Program spawns itself (argv[0]).
*/
itoa( hpipe[READ], hstr, 10 );
if( ( pid = spawnl( P_NOWAIT, argv[0], argv[0],
hstr, NULL ) ) == -1 )
printf( "Spawn failed" );

/* Put problem in write pipe. Since spawned program is
* running simultaneously, first solutions may be done
* before last problem is given.
*/
for( problem = 1000; problem <= NUMPROBLEM * 1000; problem += 1000)


printf( "Son, what is the square root of %d?\n", problem );
write( hpipe[WRITE], (char *)&problem, sizeof( int ) );



/* Wait until spawned program is done processing. */
_cwait( &termstat, pid, WAIT_CHILD );
if( termstat & 0x0 )
printf( "Child failed\n" );

close( hpipe[READ] );
close( hpipe[WRITE] );



/* If there is an argument, this must be the spawned process. */
else


/* Convert passed string handle to integer handle. */
hpipe[READ] = atoi( argv[1] );

/* Read problem from pipe and calculate solution. */
for( c = 0; c < NUMPROBLEM; c++ )


read( hpipe[READ], (char *)&problem, sizeof( int ) );
printf( "Dad, the square root of %d is %3.2f.\n",
problem, sqrt( ( double )problem ) );





Output

Son, what is the square root of 1000?
Son, what is the square root of 2000?
Son, what is the square root of 3000?
Son, what is the square root of 4000?
Son, what is the square root of 5000?
Son, what is the square root of 6000?
Son, what is the square root of 7000?
Son, what is the square root of 8000?
Dad, the square root of 1000 is 31.62.
Dad, the square root of 2000 is 44.72.
Dad, the square root of 3000 is 54.77.
Dad, the square root of 4000 is 63.25.
Dad, the square root of 5000 is 70.71.
Dad, the square root of 6000 is 77.46.
Dad, the square root of 7000 is 83.67.
Dad, the square root of 8000 is 89.44.

Example 2

// This is a simple filter application. It will spawn
// the application on command line. But before spawning
// the application, it will create a pipe that will direct the
// spawned application's stdout to the filter. The filter
// will remove ASCII 7 (beep) characters.

// Beeper.Cpp

/* Compile options needed: None */
#include <stdio.h>
#include <string.h>

int main()

int i;
for(i=0;i<100;++i)

printf("\nThis is speaker beep number %d... \n\7", i+1);

return 0;


// BeepFilter.Cpp
/* Compile options needed: none
Execute as: BeepFilter.exe <path>Beeper.exe
*/
#include <windows.h>
#include <process.h>
#include <memory.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

#define OUT_BUFF_SIZE 512
#define READ_HANDLE 0
#define WRITE_HANDLE 1
#define BEEP_CHAR 7

char szBuffer[OUT_BUFF_SIZE];

int Filter(char* szBuff, ULONG nSize, int nChar)

char* szPos = szBuff + nSize -1;
char* szEnd = szPos;
int nRet = nSize;

while (szPos > szBuff)

if (*szPos == nChar)

memmove(szPos, szPos+1, szEnd - szPos);
--nRet;

--szPos;

return nRet;


int main(int argc, char** argv)

int nExitCode = STILL_ACTIVE;
if (argc >= 2)

HANDLE hProcess;
int hStdOut;
int hStdOutPipe[2];

// Create the pipe
if(_pipe(hStdOutPipe, 512, O_BINARY
------解决方案--------------------
O_NOINHERIT) == -1)
return 1;

// Duplicate stdout handle (next line will close original)
hStdOut = _dup(_fileno(stdout));

// Duplicate write end of pipe to stdout handle
if(_dup2(hStdOutPipe[WRITE_HANDLE], _fileno(stdout)) != 0)
return 2;

// Close original write end of pipe
close(hStdOutPipe[WRITE_HANDLE]);

// Spawn process
hProcess = (HANDLE)spawnvp(P_NOWAIT, argv[1],
(const char* const*)&argv[1]);

// Duplicate copy of original stdout back into stdout
if(_dup2(hStdOut, _fileno(stdout)) != 0)
return 3;

// Close duplicate copy of original stdout
close(hStdOut);

if(hProcess)

int nOutRead;
while (nExitCode == STILL_ACTIVE)

nOutRead = read(hStdOutPipe[READ_HANDLE],
szBuffer, OUT_BUFF_SIZE);
if(nOutRead)

nOutRead = Filter(szBuffer, nOutRead, BEEP_CHAR);
fwrite(szBuffer, 1, nOutRead, stdout);


if(!GetExitCodeProcess(hProcess,(unsigned long*)&nExitCode))
return 4;




printf("\nPress \'ENTER\' key to continue... ");
getchar();
return nExitCode;


Process and Environment Control Routines

See Also _open本回答被提问者采纳