C++ C++；jobjectarray返回方法的NDK库内存管理

//******新问题*****

当结构被传递到线程时，下面有一个内存泄漏。无法理解原因，因为线程内的代码如果在主线程中直接调用，不会泄漏内存

class PeopleCounting{

  // Class variables
  Ptr<cv::BackgroundSubtractorMOG2> pMOG2 = cv::createBackgroundSubtractorMOG2(500, 16);
  Mat maskBackgroundSubtracted = Mat(resizeDimension.height, resizeDimension.width, CV_8UC1);

  // Thread creation code below, code called from main.

    //Create thread
    pthread_t threads;
    pthread_attr_t attr;
    void *status;

    // Initialize and set thread joinable
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    // Creating thread data and initializing it
    BackgroundSubstractionThreadData threadData = {CamImage, maskBackgroundSubtracted, pMOG2};
    int rc;
    rc = pthread_create(&threads, NULL, performBackgroundSubstraction, (void *)&threadData);
    if (rc)
    {
        __android_log_print(ANDROID_LOG_ERROR, APPNAME, "Error: peopleCountingMainMono unable to create thread  - %d",rc);
    }
    // free attribute and wait for the other threads
    pthread_attr_destroy(&attr);

    // ************** Do something else in main thread **************

    // Join thread i.e. wait till completion of thread
    rc = pthread_join(threads, &status);
    if (rc)
    {
        __android_log_print(ANDROID_LOG_ERROR, APPNAME, "Error: peopleCountingMainMono unable to join - %d",rc);
    }

    // Using class variable **maskBackgroundSubtracted** and **pMOG2** for later use. **CamImage** (opencv mat) usually gets released automatically in general due to smart pointer implementation, not sure if it is the source of leak

}

// Note: Outside class
void *performBackgroundSubstraction(void *threadarg)
  {
  struct BackgroundSubstractionThreadData *my_data;
  my_data = (struct BackgroundSubstractionThreadData *)threadarg;

  Mat fgMask;
  my_data->pMOG2F->apply(my_data->leftCamImage, fgMask, 0.002);

  morphologyEx(fgMask, fgMask, MORPH_OPEN, getStructuringElement(MORPH_RECT, Size(3, 3)),Point(-1,-1),1);
  morphologyEx(fgMask, fgMask, MORPH_CLOSE, getStructuringElement(MORPH_RECT, Size(11, 11)),Point(-1,-1),1);
  threshold(fgMask, my_data->dst, 128, 255, THRESH_BINARY);
  pthread_exit(NULL);
  };

class人员计数{
//类变量
Ptr pMOG2=cv:：createBackgroundSubtractorMOG2（500,16）；
Mat MaskBackground减去=Mat（resizeDimension.height，resizeDimension.width，CV_8UC1）；
//下面是线程创建代码，代码从main调用。
//创建线程
pthread_t线程；
pthread_attr_t attr；
无效*状态；
//初始化并设置线程可连接
pthread_attr_init（&attr）；
pthread_attr_setdetachstate（&attr，pthread_CREATE_JOINABLE）；
//创建线程数据并初始化它
BackgroundSubstrationReadData threadData={CamImage，maskBackgroundSubtracted，pMOG2}；
int rc；
rc=pthread_创建（&threads，NULL，performbackgroundsubstration，（void*）&threadData）；
if（rc）
{
__android_日志_打印（android_日志_错误，APPNAME，“错误：peopleCountingMainMono无法创建线程-%d”，rc）；
}
//释放属性并等待其他线程
pthread_attr_destroy（&attr）；
//*************在主线程中执行其他操作**************
//连接线程，即等待线程完成
rc=pthread_join（线程和状态）；
if（rc）
{
__android_日志_打印（android_日志_错误，APPNAME，“错误：peopleCountingMainMono无法加入-%d”，rc）；
}
//使用类变量**maskBackgroundSubtracted**和**pMOG2**供以后使用。**CamImage**（opencv mat）通常会由于智能指针实现而自动释放，不确定它是否是泄漏源
}
//注：课外
void*performbackgroundsubstration（void*threadarg）
{
struct BackgroundSubstrationReadData*my_数据；
my_data=（结构背景SubstrationReadData*）线程arg；
Mat-FG面罩；
my_data->pMOG2F->apply（my_data->leftCamImage，fgMask，0.002）；
morphologyEx（fgMask，fgMask，MORPH_OPEN，getStructuringElement（MORPH_RECT，Size（3,3）），点（-1，-1），1）；
morphologyEx（fgMask，fgMask，MORPH_CLOSE，getStructuringElement（MORPH_RECT，Size（11,11）），点（-1，-1），1）；
阈值（fgMask，我的数据->dst，128，255，阈值二进制）；
pthread_exit（NULL）；
};

//******问题结束****

我有一个NDK库，它有一个JNI函数，返回jobjectArray

在下面的代码中，我使用的是一个静态全局jPeopleCountArray，它通过一个循环填充jobject并返回给Java调用方法。这个JNI函数通过Java代码中的循环一次又一次地调用，但一次只调用一个实例，因此允许全局返回对象。在库使用结束时，我通过循环jobject数组并删除jobject的本地ref，最后删除jPeopleCountArray的全局ref来执行内存清理。内存清理只在最后执行，因为迭代使用（但只有单个实例）允许重用返回对象

问题是何时通过NewObjectArray分配全局jobjectArray。由于上一次调用而保留在jobjectArray中的所有jobjects是否从内存中释放

class PeopleCounting{
  public:
    static inline jobjectArray jPeopleCountArray = NULL;
    static inline JNI_PEOPLECOUNT * jniPeopleCount = NULL;
  // .... Rest of Code ...
}


// JNI function
    PeopleCounting *obj = (PeopleCounting *) hEngineHandle;

    obj->LoadJniPeopleCount(env);
    Mat *pMatCGray = (Mat *) addrCamGray;

    vector<PeopleSegment> peopleCountingFromContourRes = obj->peopleCountingMainMono(
            *pMatCGray);

    // ******** IMPORTANT BELOW *********        
    obj->jPeopleCountArray = env->NewObjectArray(peopleCountingFromContourRes.size(),
                                            obj->jniPeopleCount->cls, NULL);
    for (size_t i = 0; i < peopleCountingFromContourRes.size(); i++) {
        jobject jPeopleCount = env->NewObject(obj->jniPeopleCount->cls,
                                              obj->jniPeopleCount->constructortorID);
        obj->FillPeopleCountValuesToJni(env, jPeopleCount, peopleCountingFromContourRes[i]);
        env->SetObjectArrayElement(obj->jPeopleCountArray, i, jPeopleCount);
    }
    return obj->jPeopleCountArray;



// Memory cleanup at the end of library use.
PeopleCounting *obj = (PeopleCounting *) hEngineHandle;
if (obj->jPeopleCountArray != NULL){
    __android_log_print(ANDROID_LOG_VERBOSE, APPNAME,
                        "Freeing memory of jobject array");
    //https://www.ibm.com/developerworks/library/j-jni/index.html
    int size = env->GetArrayLength(obj->jPeopleCountArray);
    for(int i = 0; i < size; i++)
    {
        jobject row = env->GetObjectArrayElement(obj->jPeopleCountArray, i);
        if(env->ExceptionOccurred()) {
            break;
        }
        env->DeleteLocalRef(row);
    }
    env->DeleteGlobalRef(obj->jPeopleCountArray);
}

delete (PeopleCounting *)(hEngineHandle);

class人员计数{
公众：
静态内联jobjectArray JPeopCountArray=NULL；
静态内联JNI_PEOPLECOUNT*jniPeopleCount=NULL；
//…代码的其余部分。。。
}
//JNI函数
PeopleCounting*obj=（PeopleCounting*）hEngineHandle；
obj->LoadJniPeopleCount（环境）；
Mat*pMatCGray=（Mat*）addrCamGray；
向量peopleCountingFromContourRes=obj->peopleCountingMainMono(
*pMatCGray）；
//*******重要信息如下**********
obj->jPeopleCountArray=env->NewObjectArray（peopleCountingFromContourRes.size（），
obj->jniPeopleCount->cls，空）；
对于（size_t i=0；iNewObject（obj->jniPeopleCount->cls，
obj->jniPeopleCount->constructortorID）；
obj->将PeopleCountValues填入JNI（env，jpePeopleCount，peopleCountingFromContourRes[i]）；
env->SetObjectArrayElement（obj->jpeopCountArray，i，jpeopCount）；
}
返回obj->jpeopecountarray；
//库使用结束时的内存清理。
PeopleCounting*obj=（PeopleCounting*）hEngineHandle；
if（obj->jPeopleCountArray！=NULL）{
__android_日志_打印（android_日志_详细，APPNAME，
“释放jobject数组的内存”）；
//https://www.ibm.com/developerworks/library/j-jni/index.html
int size=env->GetArrayLength（obj->jpeopCountArray）；
对于（int i=0；iGetObjectArrayElement（obj->jPeopleCountArray，i）；
如果（环境->例外发生（））{
打破
}
env->DeleteLocalRef（行）；
}
env->DeleteGlobalRef（obj->jPeopleCountArray）；
}
删除（PeopleCounting*）（hEngineHandle）；

您的代码可能会耗尽非常有限的本地引用表（其大小取决于实现，但可能低至256）

您可以在创建的循环中删除对jpeopecount的本地引用，就在

SetObjectArrayElement（…，jpeopeCount）

之后。另一方面，所有这些本地引用将在JNI函数返回obj->jPeopleCountArray后自动释放

类似地，删除对obj->jPeopleCountArray元素的本地引用的循环是冗余的。在使用GetObjectArrayElement（）创建这些引用之前，不存在要处理的本地引用

这说明了本地引用和全局引用之间的行为差异。您不需要创建对的全局引用