问题思维导图

              性能调优与故障排查
                     |
        ┌────────────┼────────────┐
        |            |            |
    性能问题    内存问题    调试问题
        |            |            |
    ┌───┴───┐    ┌───┴───┐    ┌───┴───┐
    |       |    |       |    |       |
  JNI   调用   内存  引用   日志  性能
  开销  阻塞   泄漏  泄漏   不足  分析

---

问题一：JNI调用的性能瓶颈

问题描述

JNI调用存在显著的性能开销：

• 虚拟机上下文切换：每次调用都需要从C++切换到Java
• 数据转换：参数和返回值需要转换
• 方法查找：每次都需要查找方法ID
• 异常检查：每次调用后都需要检查异常

在高频调用场景下，这些开销会累积，导致应用响应迟缓。

问题流程图

调用JNI方法1000次
    |
    ├─→ 第1次调用
    |   ├─→ 查找方法ID ──→ 100μs
    |   ├─→ 上下文切换 ──→ 50μs
    |   ├─→ 数据转换 ──→ 30μs
    |   ├─→ 异常检查 ──→ 20μs
    |   └─→ 总耗时 ──→ 200μs
    |
    ├─→ 第2-1000次调用
    |   └─→ 每次200μs × 999 = 199.8ms
    |
    └─→ 总耗时 ──→ 200ms ❌ 太慢！

解决方案：JNI调用优化

// jni_performance_optimizer.h
#ifndef JNI_PERFORMANCE_OPTIMIZER_H
#define JNI_PERFORMANCE_OPTIMIZER_H

#include <jni.h>
#include <QString>
#include <QMap>
#include <QMutex>
#include <functional>
#include <chrono>

class JNIPerformanceOptimizer {
public:
    // 方法ID缓存
    static jmethodID getCachedMethodID(const QString &className,
                                       const QString &methodName,
                                       const QString &signature);
    
    // 字段ID缓存
    static jfieldID getCachedFieldID(const QString &className,
                                     const QString &fieldName,
                                     const QString &signature);
    
    // 类引用缓存
    static jclass getCachedClass(const QString &className);
    
    // 批量JNI调用
    template<typename Func>
    static auto batchCall(Func func) -> decltype(func(nullptr))
    {
        JNIEnv *env = getJNIEnv();
        if (env == nullptr) {
            return decltype(func(nullptr))();
        }
        
        return func(env);
    }
    
    // 性能测量
    static long long measureJNICall(std::function<void(JNIEnv *)> func);
    
    // 获取性能统计
    static QString getPerformanceStats();
    
    // 清空缓存
    static void clearCache();

private:
    JNIPerformanceOptimizer() = default;
    
    static JNIEnv *getJNIEnv();
    
    struct MethodCache {
        jmethodID id;
        long long callCount;
        long long totalTime;
    };
    
    static QMap<QString, jmethodID> s_methodCache;
    static QMap<QString, jfieldID> s_fieldCache;
    static QMap<QString, jclass> s_classCache;
    static QMap<QString, MethodCache> s_performanceStats;
    static QMutex s_cacheMutex;
};

#endif // JNI_PERFORMANCE_OPTIMIZER_H

文字解释：

这个优化器类提供了JNI调用的性能优化。通过缓存方法ID、字段ID和类引用，避免重复查找。batchCall()模板方法允许在一个JNI环境中执行多个操作，减少上下文切换。measureJNICall()测量单个调用的耗时，getPerformanceStats()提供性能统计信息。

// jni_performance_optimizer.cpp
#include "jni_performance_optimizer.h"
#include <QAndroidJniEnvironment>
#include <QDebug>

QMap<QString, jmethodID> JNIPerformanceOptimizer::s_methodCache;
QMap<QString, jfieldID> JNIPerformanceOptimizer::s_fieldCache;
QMap<QString, jclass> JNIPerformanceOptimizer::s_classCache;
QMap<QString, JNIPerformanceOptimizer::MethodCache> JNIPerformanceOptimizer::s_performanceStats;
QMutex JNIPerformanceOptimizer::s_cacheMutex;

JNIEnv *JNIPerformanceOptimizer::getJNIEnv()
{
    QAndroidJniEnvironment env;
    return env.jniEnv();
}

jmethodID JNIPerformanceOptimizer::getCachedMethodID(const QString &className,
                                                     const QString &methodName,
                                                     const QString &signature)
{
    QMutexLocker locker(&s_cacheMutex);
    
    QString cacheKey = className + "." + methodName + signature;
    
    // 检查缓存
    if (s_methodCache.contains(cacheKey)) {
        return s_methodCache[cacheKey];
    }
    
    // 从JNI获取
    JNIEnv *env = getJNIEnv();
    if (env == nullptr) {
        return nullptr;
    }
    
    jclass clazz = env->FindClass(className.toStdString().c_str());
    if (clazz == nullptr) {
        qWarning() << "Class not found:" << className;
        return nullptr;
    }
    
    jmethodID methodId = env->GetMethodID(
        clazz, methodName.toStdString().c_str(),
        signature.toStdString().c_str());
    
    if (methodId != nullptr) {
        s_methodCache[cacheKey] = methodId;
        
        // 初始化性能统计
        MethodCache cache;
        cache.id = methodId;
        cache.callCount = 0;
        cache.totalTime = 0;
        s_performanceStats[cacheKey] = cache;
    }
    
    env->DeleteLocalRef(clazz);
    return methodId;
}

jclass JNIPerformanceOptimizer::getCachedClass(const QString &className)
{
    QMutexLocker locker(&s_cacheMutex);
    
    if (s_classCache.contains(className)) {
        return s_classCache[className];
    }
    
    JNIEnv *env = getJNIEnv();
    if (env == nullptr) {
        return nullptr;
    }
    
    jclass clazz = env->FindClass(className.toStdString().c_str());
    if (clazz != nullptr) {
        // 创建全局引用
        jclass globalRef = (jclass)env->NewGlobalRef(clazz);
        s_classCache[className] = globalRef;
        env->DeleteLocalRef(clazz);
        return globalRef;
    }
    
    return nullptr;
}

long long JNIPerformanceOptimizer::measureJNICall(std::function<void(JNIEnv *)> func)
{
    auto start = std::chrono::high_resolution_clock::now();
    
    JNIEnv *env = getJNIEnv();
    if (env != nullptr) {
        func(env);
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
        end - start).count();
    
    return duration;
}

QString JNIPerformanceOptimizer::getPerformanceStats()
{
    QMutexLocker locker(&s_cacheMutex);
    
    QString stats = "=== JNI Performance Statistics ===\n";
    stats += QString("Cached methods: %1\n").arg(s_methodCache.size());
    stats += QString("Cached classes: %1\n\n").arg(s_classCache.size());
    
    stats += "Method Call Statistics:\n";
    for (auto it = s_performanceStats.begin(); it != s_performanceStats.end(); ++it) {
        const MethodCache &cache = it.value();
        if (cache.callCount > 0) {
            long long avgTime = cache.totalTime / cache.callCount;
            stats += QString("%1: %2 calls, avg %3μs\n")
                    .arg(it.key())
                    .arg(cache.callCount)
                    .arg(avgTime);
        }
    }
    
    return stats;
}

void JNIPerformanceOptimizer::clearCache()
{
    QMutexLocker locker(&s_cacheMutex);
    
    JNIEnv *env = getJNIEnv();
    if (env != nullptr) {
        for (auto it = s_classCache.begin(); it != s_classCache.end(); ++it) {
            env->DeleteGlobalRef(it.value());
        }
    }
    
    s_methodCache.clear();
    s_fieldCache.clear();
    s_classCache.clear();
    s_performanceStats.clear();
}

文字解释：

这段实现代码展示了JNI调用的优化策略。getCachedMethodID()首先检查缓存，如果没有则从JNI获取并缓存。getCachedClass()创建全局引用以保持有效性。measureJNICall()使用高精度计时器测量调用耗时。getPerformanceStats()生成详细的性能报告，显示每个方法的调用次数和平均耗时。通过这些优化，可以显著提升JNI调用的性能。

---

问题二：内存泄漏与引用泄漏

问题描述

JNI中容易出现内存泄漏：

• 局部引用在循环中堆积
• 全局引用忘记释放
• 异常发生时资源未清理
• 线程退出时环境未清理

问题流程图

内存泄漏诊断流程
    |
    ├─→ 启动应用
    |   └─→ 内存: 100MB
    |
    ├─→ 运行1小时
    |   └─→ 内存: 200MB ⚠️ 泄漏100MB
    |
    ├─→ 运行2小时
    |   └─→ 内存: 300MB ⚠️ 继续泄漏
    |
    └─→ 运行3小时
        └─→ 内存: 400MB ❌ 应用崩溃！

解决方案：内存泄漏检测与修复

// memory_leak_detector.h
#ifndef MEMORY_LEAK_DETECTOR_H
#define MEMORY_LEAK_DETECTOR_H

#include <jni.h>
#include <QString>
#include <QMap>
#include <QMutex>
#include <memory>

class MemoryLeakDetector {
public:
    static MemoryLeakDetector &instance();
    
    // 记录对象分配
    void trackAllocation(const QString &type, jobject obj, 
                        const QString &location);
    
    // 记录对象释放
    void trackDeallocation(const QString &type, jobject obj);
    
    // 生成泄漏报告
    QString generateLeakReport() const;
    
    // 检查特定类型的泄漏
    int getLeakCount(const QString &type) const;
    
    // 启用/禁用检测
    void setEnabled(bool enabled);
    
    // 清空统计
    void reset();

private:
    MemoryLeakDetector() : m_enabled(false) {}
    
    struct AllocationInfo {
        QString type;
        QString location;
        long long timestamp;
        size_t size;
    };
    
    QMap<jobject, AllocationInfo> m_allocations;
    mutable QMutex m_mutex;
    bool m_enabled;
};

#endif // MEMORY_LEAK_DETECTOR_H

文字解释：

这个检测器类追踪所有JNI对象的分配和释放。trackAllocation()记录对象分配时的位置和时间，trackDeallocation()记录释放。通过比较分配和释放的对象，可以识别未被释放的对象。generateLeakReport()生成详细的泄漏报告，包括泄漏对象的类型、位置和数量。

// memory_leak_detector.cpp
#include "memory_leak_detector.h"
#include <QDateTime>
#include <QDebug>

MemoryLeakDetector &MemoryLeakDetector::instance()
{
    static MemoryLeakDetector detector;
    return detector;
}

void MemoryLeakDetector::trackAllocation(const QString &type, jobject obj,
                                         const QString &location)
{
    if (!m_enabled) {
        return;
    }
    
    QMutexLocker locker(&m_mutex);
    
    AllocationInfo info;
    info.type = type;
    info.location = location;
    info.timestamp = QDateTime::currentMSecsSinceEpoch();
    info.size = 0; // 可以通过JNI获取对象大小
    
    m_allocations[obj] = info;
    
    qDebug() << "Allocated" << type << "at" << location;
}

void MemoryLeakDetector::trackDeallocation(const QString &type, jobject obj)
{
    if (!m_enabled) {
        return;
    }
    
    QMutexLocker locker(&m_mutex);
    
    auto it = m_allocations.find(obj);
    if (it != m_allocations.end()) {
        m_allocations.erase(it);
        qDebug() << "Deallocated" << type;
    } else {
        qWarning() << "Deallocating unknown object of type" << type;
    }
}

QString MemoryLeakDetector::generateLeakReport() const
{
    QMutexLocker locker(&m_mutex);
    
    QString report = "=== Memory Leak Report ===\n";
    report += QString("Total leaked objects: %1\n\n").arg(m_allocations.size());
    
    QMap<QString, int> typeCount;
    QMap<QString, QStringList> locations;
    
    for (const auto &info : m_allocations) {
        typeCount[info.type]++;
        locations[info.type].append(info.location);
    }
    
    for (auto it = typeCount.begin(); it != typeCount.end(); ++it) {
        report += QString("Type: %1, Count: %2\n").arg(it.key()).arg(it.value());
        
        for (const QString &location : locations[it.key()]) {
            report += QString("  Location: %1\n").arg(location);
        }
        
        report += "\n";
    }
    
    return report;
}

int MemoryLeakDetector::getLeakCount(const QString &type) const
{
    QMutexLocker locker(&m_mutex);
    
    int count = 0;
    for (const auto &info : m_allocations) {
        if (info.type == type) {
            count++;
        }
    }
    
    return count;
}

void MemoryLeakDetector::setEnabled(bool enabled)
{
    m_enabled = enabled;
}

void MemoryLeakDetector::reset()
{
    QMutexLocker locker(&m_mutex);
    m_allocations.clear();
}

文字解释：

这段实现代码展示了内存泄漏检测的具体逻辑。trackAllocation()记录分配的对象及其位置。trackDeallocation()从追踪列表中删除对象。generateLeakReport()统计各类型对象的泄漏数量和位置，便于定位问题。通过在开发阶段启用检测，可以及时发现和修复内存泄漏。

---

问题三：调试与日志记录

问题描述

JNI调用的调试困难：

• 崩溃堆栈信息不完整
• JNI异常信息难以追踪
• 性能问题难以定位
• 跨语言调用链难以理解

问题流程图

应用崩溃
    |
    ├─→ 没有日志 ──→ ❌ 无法定位问题
    |
    ├─→ 日志不详细 ──→ ⚠️ 信息不足
    |
    ├─→ 日志混乱 ──→ ⚠️ 难以追踪
    |
    └─→ 结构化日志 ──→ ✓ 快速定位问题

解决方案：结构化日志系统

// jni_logger.h
#ifndef JNI_LOGGER_H
#define JNI_LOGGER_H

#include <QString>
#include <QFile>
#include <QMutex>
#include <functional>

enum class LogLevel {
    DEBUG,
    INFO,
    WARNING,
    ERROR,
    CRITICAL
};

class JNILogger {
public:
    static JNILogger &instance();
    
    // 设置日志级别
    void setLogLevel(LogLevel level);
    
    // 记录日志
    void log(LogLevel level, const QString &category, const QString &message);
    
    // 便捷方法
    void debug(const QString &category, const QString &message);
    void info(const QString &category, const QString &message);
    void warning(const QString &category, const QString &message);
    void error(const QString &category, const QString &message);
    void critical(const QString &category, const QString &message);
    
    // 记录JNI异常
    void logJNIException(JNIEnv *env, const QString &context);
    
    // 记录方法调用
    void logMethodCall(const QString &className, const QString &methodName);
    void logMethodReturn(const QString &className, const QString &methodName,
                        long long durationMs);
    
    // 获取日志文件路径
    QString getLogFilePath() const;
    
    // 清空日志
    void clearLogs();

private:
    JNILogger();
    
    QString levelToString(LogLevel level) const;
    QString getCurrentTimestamp() const;
    
    LogLevel m_logLevel;
    QFile m_logFile;
    QMutex m_mutex;
};

#endif // JNI_LOGGER_H

文字解释：

这个日志系统提供了结构化的日志记录。setLogLevel()控制日志详细程度。log()方法记录带有时间戳、级别和分类的日志。logJNIException()专门处理JNI异常的记录。logMethodCall()和logMethodReturn()记录方法调用和返回，便于追踪执行流程。

// jni_logger.cpp
#include "jni_logger.h"
#include <QDateTime>
#include <QDebug>
#include <QStandardPaths>
#include <QDir>

JNILogger &JNILogger::instance()
{
    static JNILogger logger;
    return logger;
}

JNILogger::JNILogger() : m_logLevel(LogLevel::INFO)
{
    // 初始化日志文件
    QString logDir = QStandardPaths::writableLocation(
        QStandardPaths::AppDataLocation);
    QDir().mkpath(logDir);
    
    QString logPath = logDir + "/jni_bridge.log";
    m_logFile.setFileName(logPath);
    m_logFile.open(QIODevice::Append | QIODevice::Text);
}

void JNILogger::setLogLevel(LogLevel level)
{
    m_logLevel = level;
}

void JNILogger::log(LogLevel level, const QString &category, 
                    const QString &message)
{
    if (level < m_logLevel) {
        return;
    }
    
    QMutexLocker locker(&m_mutex);
    
    QString timestamp = getCurrentTimestamp();
    QString levelStr = levelToString(level);
    QString logMessage = QString("[%1] [%2] [%3] %4\n")
                        .arg(timestamp, levelStr, category, message);
    
    // 写入文件
    if (m_logFile.isOpen()) {
        m_logFile.write(logMessage.toUtf8());
        m_logFile.flush();
    }
    
    // 也输出到调试器
    qDebug().noquote() << logMessage;
}

void JNILogger::debug(const QString &category, const QString &message)
{
    log(LogLevel::DEBUG, category, message);
}

void JNILogger::info(const QString &category, const QString &message)
{
    log(LogLevel::INFO, category, message);
}

void JNILogger::warning(const QString &category, const QString &message)
{
    log(LogLevel::WARNING, category, message);
}

void JNILogger::error(const QString &category, const QString &message)
{
    log(LogLevel::ERROR, category, message);
}

void JNILogger::critical(const QString &category, const QString &message)
{
    log(LogLevel::CRITICAL, category, message);
}

void JNILogger::logJNIException(JNIEnv *env, const QString &context)
{
    if (env == nullptr || !env->ExceptionCheck()) {
        return;
    }
    
    jthrowable exception = env->ExceptionOccurred();
    jclass exceptionClass = env->GetObjectClass(exception);
    jmethodID toStringMethod = env->GetMethodID(
        exceptionClass, "toString", "()Ljava/lang/String;");
    
    jstring message = (jstring)env->CallObjectMethod(exception, toStringMethod);
    const char *nativeMessage = env->GetStringUTFChars(message, nullptr);
    
    QString errorMsg = QString("JNI Exception in %1: %2")
                      .arg(context, nativeMessage);
    
    error("JNI", errorMsg);
    
    env->ReleaseStringUTFChars(message, nativeMessage);
    env->ExceptionClear();
}

void JNILogger::logMethodCall(const QString &className, 
                             const QString &methodName)
{
    QString message = QString("Calling %1::%2")
                     .arg(className, methodName);
    debug("JNI_CALL", message);
}

void JNILogger::logMethodReturn(const QString &className,
                               const QString &methodName,
                               long long durationMs)
{
    QString message = QString("Returned from %1::%2 (duration: %3ms)")
                     .arg(className, methodName).arg(durationMs);
    debug("JNI_RETURN", message);
}

QString JNILogger::getLogFilePath() const
{
    return m_logFile.fileName();
}

void JNILogger::clearLogs()
{
    QMutexLocker locker(&m_mutex);
    
    if (m_logFile.isOpen()) {
        m_logFile.close();
    }
    
    m_logFile.remove();
    m_logFile.open(QIODevice::WriteOnly | QIODevice::Text);
}

QString JNILogger::levelToString(LogLevel level) const
{
    switch (level) {
    case LogLevel::DEBUG:
        return "DEBUG";
    case LogLevel::INFO:
        return "INFO";
    case LogLevel::WARNING:
        return "WARN";
    case LogLevel::ERROR:
        return "ERROR";
    case LogLevel::CRITICAL:
        return "CRITICAL";
    default:
        return "UNKNOWN";
    }
}

QString JNILogger::getCurrentTimestamp() const
{
    return QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz");
}

文字解释：

这段实现代码展示了完整的日志系统。日志同时写入文件和调试器。每条日志都包含时间戳、级别、分类和消息。logJNIException()捕获并记录JNI异常。logMethodCall()和logMethodReturn()记录方法调用的开始和结束，便于追踪执行流程和性能问题。通过结构化的日志，可以快速定位和诊断问题。

---

最佳实践总结

问题	解决方案	关键点
JNI性能	缓存+批处理	减少查找和上下文切换
内存泄漏	检测+追踪	及时发现和修复
调试困难	结构化日志	详细记录执行流程
异常处理	异常捕获+记录	不遗漏任何错误

调试技巧

// 启用详细日志
JNILogger::instance().setLogLevel(LogLevel::DEBUG);

// 启用内存检测
MemoryLeakDetector::instance().setEnabled(true);

// 获取性能报告
qDebug() << JNIPerformanceOptimizer::getPerformanceStats();

// 生成泄漏报告
qDebug() << MemoryLeakDetector::instance().generateLeakReport();

通过这些工具和方法，可以有效地优化性能和排查故障。

欢迎加入开源鸿蒙PC社区：https://harmonypc.csdn.net/