如何检查LogCat -f进程是否已运行？解决重复日志写入问题

你猜的没错——每次Activity重建时，旧的logcat -f进程并没有被终止，多个进程同时监听系统日志，自然会把同一条日志重复写入文件。下面给你几个实用的解决思路：

1. 用单例模式全局管理Logcat进程 #

最稳妥的方式是创建一个全局单例类，专门负责Logcat进程的启动和销毁，确保同一时间只有一个Logcat进程在运行。

示例代码：

public class LogManager {
    private static LogManager instance;
    private Process logcatProcess;

    private LogManager() {}

    public static synchronized LogManager getInstance() {
        if (instance == null) {
            instance = new LogManager();
        }
        return instance;
    }

    public void startLogging(String logFilePath, String logTag) {
        // 先终止已存在的进程
        stopLogging();
        try {
            // 清空旧日志（可选）
            Runtime.getRuntime().exec("logcat -c");
            // 启动新的Logcat进程
            String command = String.format("logcat -f %s %s:V *:E", logFilePath, logTag);
            logcatProcess = Runtime.getRuntime().exec(command);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void stopLogging() {
        if (logcatProcess != null && logcatProcess.isAlive()) {
            logcatProcess.destroy();
            logcatProcess = null;
        }
    }
}

然后在你的Activity里调用：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // 启动日志记录
    LogManager.getInstance().startLogging(
        new File("pathToLogFile").getAbsolutePath(),
        Setting.getInstance().logKey
    );
}

@Override
protected void onDestroy() {
    super.onDestroy();
    // 注意：如果是配置变化导致的Activity重建（比如旋转屏幕），这里不要销毁进程
    // 可以通过isChangingConfigurations()判断：
    if (!isChangingConfigurations()) {
        LogManager.getInstance().stopLogging();
    }
}

这个方案的好处是完全由代码控制进程生命周期，避免重复启动，同时能在App退出时确保进程被销毁。

2. 启动新进程前杀掉旧的Logcat进程 #

如果不想用单例，也可以在每次启动Logcat前，先查找并杀掉已运行的logcat -f进程。可以通过ps命令筛选进程，再执行kill：

示例方法：

private void killExistingLogcatProcess() {
    try {
        // 执行ps命令获取进程列表
        Process psProcess = Runtime.getRuntime().exec("ps");
        BufferedReader reader = new BufferedReader(new InputStreamReader(psProcess.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            // 查找包含"logcat -f"的进程（不同Android版本ps输出格式可能有差异，需适配）
            if (line.contains("logcat") && line.contains("-f")) {
                // 提取PID（通常是第二个字段）
                String[] parts = line.trim().split("\\s+");
                if (parts.length >= 2) {
                    String pid = parts[1];
                    Runtime.getRuntime().exec("kill " + pid);
                }
            }
        }
        reader.close();
        psProcess.waitFor();
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }
}

然后在onCreate里先调用这个方法，再启动新的Logcat进程：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    killExistingLogcatProcess();
    Runtime.getRuntime().exec("logcat -c");
    File logFile = new File("pathToLogFile");
    Runtime.getRuntime().exec("logcat -f " + logFile.getAbsolutePath() + " " + Setting.getInstance().logKey + ":V *:E");
}

注意：这种方式需要处理不同Android版本的ps输出格式差异，而且可能需要额外的权限（不过一般杀自己App启动的进程不需要特殊权限）。

3. 改用Android内置的Logcat API（Android 11+） #

从Android 11（API 30）开始，系统提供了android.util.Logcat类，可以直接在代码中监听日志，不需要启动独立的Logcat进程，从根源避免多进程问题：

示例代码：

import android.util.Logcat;
import android.util.Logcat.LogListener;

// 在合适的地方初始化日志监听
private void initLogcatListener(String logFilePath, String logTag) {
    // 清空旧日志
    Logcat.clear();
    // 创建日志监听器
    LogListener listener = (entry) -> {
        // 将日志写入文件
        try (FileWriter writer = new FileWriter(logFilePath, true)) {
            writer.write(entry.getMessage() + "\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    };
    // 注册监听器，只监听指定Tag的Verbose级别及以上，其他Tag只监听Error级别
    Logcat.registerListener(
        new Logcat.Config.Builder()
            .addFilter(logTag, Logcat.LogLevel.VERBOSE)
            .addFilter("*", Logcat.LogLevel.ERROR)
            .build(),
        listener,
        Looper.getMainLooper() // 可选，指定回调线程
    );
}

这个方案最优雅，但只支持Android 11及以上版本，如果你需要兼容更低版本的系统，还是用前两种方案。

关于你问的「是否有办法检查logcat -f命令是否已运行？」，有两种方式：

• 自己维护进程引用：比如上面单例模式里的logcatProcess.isAlive()，直接判断进程是否存活。
• 通过系统命令查询：就是上面方案2里的ps命令筛选进程，找到包含logcat -f的条目，就说明进程在运行。

内容的提问来源于stack exchange，提问作者james