博客

1、前言：


最近在做一个需求需要调用linux下的ffmpeg来对视频进行处理，很简单的需求，我像往常一样写下如下的代码片段：

String cmd = “ffmpeg -i xxx”;

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

process.waitFor();

But当我运行代码时，发现代码执行到waitFor后阻塞住了，我以为这也许是ffmpeg处理视频需要时间，毕竟是同步阻塞的方法，那我就等一会吧！

一分钟……两分钟……10分钟……

我渐渐的意识到，这TM不对劲啊！

于是我通过以下命令查询了下linux执行情况。

ps -aux

输出的结果显示该脚本当前还在运行，而脚本的日志并没有从inputstream进行输出。我渐渐的慌了！因为我在linux环境下直接执行ffmpeg -i xxx，是没有问题的。

2 问题分析


2.1 观看JDK文档

根据查看JDK的文档，我看到Process.waitFor可能导致死锁？！仔细观看JDK的文档说明，发现文档上已经对死锁的情况进行了分析。

如果InputStream使用的buffer缓冲区有限的话，可能会导致阻塞和死锁 。

2.2 死锁原因

经过查阅资料，发现

1. 当我们使用Runtime.exec执行命令时，JAVA的线程会创建一个子进程，用于执行命令，而且子进程和JAVA线程会分别独立运行。
2. JAVA线程需要等待命令的执行完成，对命令的日志和返回值进行处理，所以我们在JAVA线程中调用Process.waitFor挂起来等待子进程完成。
3. 子进程执行时，不断的打印日志信息(ffmpeg命令会输出大量执行日志，这是导致挂起的直接原因)，我们通过Process.getInputStream和Process.getErrorStream进行获取正常输出日志和错误日志进行处理。
4. 这个时候子进程不断的向JAVA线程写入数据，而JAVA线程调用Process.waitFor后已经阻塞挂起，而子进程在不断的向JAVA线程进行写入数据，当我们的Process.getInputStream的buffer缓冲区被写满，而JAVA线程依然挂起并未消费buffer中的数据，导致子进程无法继续向buffer缓冲区中继续写入数据，导致子进程也挂起。
5. 这个时候JAVA线程和子进程都处于挂起的状态，JAVA线程等待子进程的结束，子进程等待JAVA线程对buffer缓冲区中的数据进行消费。两者在相互等待导致死锁。
   
   2.2.1 死锁原理图

   

3 解决方案


3.1 解决方案的思路

既然是由于buffer缓冲区的数据没有消费导致子进程挂起，那么我们从这里下手。1. 消费buffer缓冲区中的数据 2. 当JAVA线程调用Process.waitFor后，线程会进行挂起，那我们就使用多线程进行消费数据。

3.2 正常流程图

3.3 代码实现

下面写了一个代码实现的demo，我是在linux环境调用ffmpeg处理视频的，所以例子为执行ffmpeg命令，你可以根据自己的实际情况来重写。

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CmdUtils {
    private static final Logger logger = LoggerFactory.getLogger(CmdUtils.class);
    private static ThreadPoolExecutor executor;

    static {
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNameFormat("cmd-pool-%d").build();
        //根据实际情况创建线程池
        executor = new ThreadPoolExecutor(10,
                20,
                5,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(1024),
                namedThreadFactory,
                new ThreadPoolExecutor.AbortPolicy());
    }

    public static boolean exec(String cmd) throws IOException, InterruptedException {
        String[] cmds = {"/bin/sh", "-c", cmd};
        logger.info("exe cmd {}", cmd);
        Process process = Runtime.getRuntime().exec(cmds);

        //消费正常日志
        clearStream(process.getInputStream());
        //消费错误日志
        clearStream(process.getErrorStream());

        //i为返回值，判断是否执行成功
        int i = process.waitFor();
        if (i != 0) {
            logger.error("Failed to call shell command and the return status's is: {}", i);
            return false;
        }
        return true;
    }

    private static void clearStream(InputStream stream) {
        //处理buffer的线程
        executor.execute(new Runnable() {
            @Override
            public void run() {
                String line = null;
                try (BufferedReader in = new BufferedReader(new InputStreamReader(stream));) {
                    while ((line = in.readLine()) != null) {
                        logger.debug(line);
                    }
                } catch (IOException e) {
                    logger.error("exec error : {}", e);
                }
            }
        });
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        long start = System.currentTimeMillis();
        String cmd = String.format("ffmpeg -i %s -vf \"scale=1080:640,pad=1080:1920:0:640:black\" %s", "/input.mp4", "/out.mp4");
        boolean cmdResult = CmdUtils.exec(cmd);
        logger.info("exec cmd = {} out = {}, cost = {}", cmd, cmdResult, (System.currentTimeMillis() - start));
    }
}