Apr_pool_destroy () потока apache безопасен? - PullRequest
Новая
       31

Apr_pool_destroy () потока apache безопасен?

1 голос
/ 02 сентября 2010

Мое приложение построено с Apache и работает на Windows. Я создаю поток, используя createThread (), а затем для каждого потока, выполняющего ниже: 

ap_run_sub_req( subrequest );   
ap_rflush( subrequest );  
ap_destroy_sub_req( subrequest );

В свою очередь ap_destroy_sub_request вызывает функцию apr_pool_destroy ().

ap_run_sub_req () выделил память для пула, а ap_destroy_sub_req () освободил выделенную память.

Если apr_pool_destroy () вызывается внутри потока, выделенная память не освобождается, в результате чего у моего приложения возникает утечка памяти. Я не смог найти в какой-либо документации по Apache упоминание о том, что apr_pool_destroy () не является поточно-безопасными функциями.

Как решить эту проблему ?? Как освободить выделенный пул внутри потоков?
Спасибо

1 Ответ

1 голос
/ 10 сентября 2010

Вот исходный код для apr_pool_destroy(): 

APR_DECLARE(void) apr_pool_destroy(apr_pool_t *pool)
{
    apr_memnode_t *active;
    apr_allocator_t *allocator;

    /* Run pre destroy cleanups */
    run_cleanups(&pool->pre_cleanups);
    pool->pre_cleanups = NULL;

    /* Destroy the subpools.  The subpools will detach themselve from
     * this pool thus this loop is safe and easy.
     */
    while (pool->child)
        apr_pool_destroy(pool->child);

    /* Run cleanups */
    run_cleanups(&pool->cleanups);

    /* Free subprocesses */
    free_proc_chain(pool->subprocesses);

    /* Remove the pool from the parents child list */
    if (pool->parent) {
#if APR_HAS_THREADS
        apr_thread_mutex_t *mutex;

        if ((mutex = apr_allocator_mutex_get(pool->parent->allocator)) != NULL)
            apr_thread_mutex_lock(mutex);
#endif /* APR_HAS_THREADS */

        if ((*pool->ref = pool->sibling) != NULL)
            pool->sibling->ref = pool->ref;

#if APR_HAS_THREADS
        if (mutex)
            apr_thread_mutex_unlock(mutex);
#endif /* APR_HAS_THREADS */
    }

    /* Find the block attached to the pool structure.  Save a copy of the
     * allocator pointer, because the pool struct soon will be no more.
     */
    allocator = pool->allocator;
    active = pool->self;
    *active->ref = NULL;

#if APR_HAS_THREADS
    if (apr_allocator_owner_get(allocator) == pool) {
        /* Make sure to remove the lock, since it is highly likely to
         * be invalid now.
         */
        apr_allocator_mutex_set(allocator, NULL);
    }
#endif /* APR_HAS_THREADS */

    /* Free all the nodes in the pool (including the node holding the
     * pool struct), by giving them back to the allocator.
     */
    allocator_free(allocator, active);

    /* If this pool happens to be the owner of the allocator, free
     * everything in the allocator (that includes the pool struct
     * and the allocator).  Don't worry about destroying the optional mutex
     * in the allocator, it will have been destroyed by the cleanup function.
     */
    if (apr_allocator_owner_get(allocator) == pool) {
        apr_allocator_destroy(allocator);
    }
}

Судя по всему, это не потокобезопасно, но я не эксперт по Си. Возможно, вам следует опубликовать в список рассылки APR .

...