调用 pthread_exit() 时内存泄漏

Question

i need to create a thread pool it,it works but in function do_work that the function pthread_create calls i have problem in the free (memory leak) just when calling pthread_exit()

*in function create threadpool i just initilaize the struct and call function do work *

void* do_work(void* p)
  {
   threadpool* pool = (threadpool*)p;
   work_t* work;
while(1)
{
    pthread_mutex_lock(&pool->qlock);
    if(pool->shutdown == 1)
    {

        pthread_mutex_unlock(&pool->qlock);
        //pthread_exit(EXIT_SUCCESS);// here is the free problem when deleting it all good
        return NULL;
    }
    while(!pool->qsize)
    { 
    if(pthread_cond_wait(&pool->q_not_empty,&pool->qlock)) 
         perror("pthread_cond_wait\n"); 
    if(pool->shutdown)
         break;
      } 

    //Check if the system is shutting down
    if(pool->shutdown == 1)
    {
        pthread_mutex_unlock(&pool->qlock);
        //pthread_exit(EXIT_SUCCESS);y
        return NULL;
    }

  work = pool->qhead;    //set the cur variable.

    pool->qsize--;        //decriment the size.

    if(pool->qsize == 0) {
        pool->qhead = NULL;
        pool->qtail = NULL;
    }
    else {
        pool->qhead = work->next;
    }

    if(pool->qsize == 0 && ! pool->shutdown) {
        //the q is empty again, now signal that its empty.
        pthread_cond_signal(&(pool->q_empty));
    }
    pthread_mutex_unlock(&(pool->qlock));
    (work->routine) (work->arg);   //actually do work.
    free(work);   

}
 }

Answer 1

The pattern looks like a fairly standard thread pool:

typedef struct {
    pthread_mutex_t   qlock;
    pthread_cond_t    q_not_empty;
    volatile work_t  *qhead;
    volatile work_t  *qtail;
    size_t            qsize; /* Not needed */
    volatile int      shutdown;
} threadpool;

Properly indenting OP's code would make it more readable.

However, the implementation looks odd. I would expect

void *do_work(void *poolptr)
{
    threadpool *const  pool = poolptr;
    work_t            *work;

    pthread_mutex_lock(&(pool->qlock));
    while (!(pool->shutdown)) {

        if (!(pool->qhead)) {
            /* Queue empty */
            pthread_cond_wait(&(pool->q_not_empty), &(pool->qlock));
            continue;
        }

        work = pool->qhead;
        pool->qhead = work->next;
        if (!pool->qhead)
             pool->qtail = NULL;
        work->next = NULL;

        pthread_unlock(&(pool->qlock));

        work->process(work);

        pthread_lock(&(pool->qlock));

    }
    pthread_mutex_unlock(&(pool->qlock));

    return (void *)0;
}

and the code that appends a new work item to the queue to be

void append(threadpool *pool, work_t *work)
{
    work->next = NULL;

    pthread_mutex_lock(&(pool->qlock));
    if (pool->qtail) {
        pool->qtail->next = work;
        pool->qtail = work;
    } else {
        pool->qhead = work;
        pool->qtail = work;
    }
    pthread_cond_signal(&(pool->q_not_empty));
    pthread_mutex_unlock(&(pool->qlock));
}

It is difficult to say where OP's implementation leaks memory. The most likely candidate is OP's arg member in each work_t , if it is dynamically allocated.

My implementation above passes the entire work_t to the routine function, which I renamed to process . It is responsible for freeing the work structure, too. The minimal definition for the work structure is

typedef struct work_t {
    struct work_t  *next;
    void          (*process)(struct work_t *);
    /* Optional other fields */
} work_t;

Other possible causes for the memory leaks is if the qsize member is not properly updated everywhere. Because there is no use for it, really, I just omit it altogether.

The simpler the code, the easier it is to avoid bugs.