将本地堆栈变量排入全局列表，以便其他线程可以使用它

Question

我有一个带有两个 pthread 的程序。

每个节点上都有一个全局变量List，用于保存(char *)。

在主线程中，我声明、malloc 并初始化一个 (char *) 并将其加入到全局列表中。

第二个线程无限循环等待全局列表中的新节点被消耗。

问题是第二个线程似乎无法使用第一个线程构建的 (char *)，因为第一个线程已经返回，所以 (char *) 可能已被释放。

有什么建议吗？

谢谢。

Answer 1

malloc 分配的内存不会在线程结束时自动释放。您还有其他问题。
也许第二个线程在一个紧密的循环中工作，所有访问都转到寄存器而不是内存。

Answer 2

全局变量：

...
static pthread_t job_handler_thread;
List jobslist = NULL;
...

init() 和构建函数（主线程）：

extern int init(void)
{
    int rc;

    jobslist = list_create(NULL);
    pthread_attr_t thread_attr;
    slurm_attr_init(&thread_attr);
    if (pthread_create(&job_handler_thread, &thread_attr,
                       _process_jobs, NULL))
            fatal("pthread_create error %m");
    slurm_mutex_lock(&pend_jobs_lock);
    rc = _load_pending_jobs();
    slurm_mutex_unlock(&pend_jobs_lock);

    return rc;
}

extern int slurm_jobcomp_log_record(struct job_record *job_ptr)
{
    char *json_job;
    int rc = SLURM_SUCCESS;

    // pass char * by reference. Inside the function
    // memory is allocated for the char *
    rc = _job_serialize(job_ptr, &json_job);

    if (rc == SLURM_SUCCESS)
            list_enqueue(jobslist, json_job);

    return rc;
}

第二个线程等待 List 节点被消耗：

extern void* _process_jobs()
{
    char *json_job;

    while(1)
    {
            if (list_is_empty(jobslist)) {
                    sleep(1);
                    continue;
            }
            json_job = list_dequeue(jobslist);
            // At this point I should process json_job
            // But data is not available here
            printf("%s", json_job);
    }

}

Answer 3

发布的代码包含几个问题，比如没有等待线程退出。

建议以下代码，该代码已在ubuntu linux 14.04上测试并正常运行

注意 pthread_mutex_lock() 和 pthread_mutex_unlock() 的使用

注意 pthread_join() 的使用

一般来说，代码需要写得越简单越好。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/wait.h>

#define MAX_JOBS     (25)
#define MAX_DATA_LEN (25)

struct node
{
    int last;
    char data[MAX_DATA_LEN];
    struct node *next;
};


static pthread_t       thread_id;
static struct node    *jobsList = NULL;
static pthread_mutex_t jobsMutex =  PTHREAD_MUTEX_INITIALIZER;

void         putNode( struct node * newNode );
struct node *getNode( void );
struct node *createNode( void );

void* process_job( void* );


int main( void )
{
    if( 0 != pthread_create( &thread_id, NULL, process_job, NULL) )
    {
        perror( "pthread_create failed" );
        exit( EXIT_FAILURE );
    }

    // implied else, pthread_create successful

    int done = 0;
    while( !done )
    {
        struct node *newNode = NULL;
        if( NULL  == (newNode = createNode() ) )
        {
            done = 1;
        }

        else
        {
            putNode( newNode );
        }
    }

    pthread_join( thread_id, NULL);
    pthread_mutex_destroy( &jobsMutex );
    return 0;
} // end function: main


struct node* createNode()
{
    static  char dataCount = 0;
    char         data[ MAX_DATA_LEN ] = {'\0'};
    struct node *newNode = NULL;

    if( MAX_JOBS > dataCount )
    {
        if( NULL != (newNode = malloc( sizeof( struct node ) ) ) )
        {
            newNode->last = ( dataCount < (MAX_JOBS-1) )? 0 : 1;
            dataCount++;
            newNode->next = NULL;

            sprintf( data, "%s %d", "this is node: ", dataCount );
            strcpy( newNode->data, data );
        }
    }

    return newNode;
} // end function: createNode


void putNode( struct node *newNode )
{
    struct node *current = NULL;

    pthread_mutex_lock( &jobsMutex );

    if( !jobsList)
    {
        jobsList = newNode;
    }

    else
    {
        for( current = jobsList; current->next; current = current->next);

        current->next = newNode;
    }

    pthread_mutex_unlock( &jobsMutex );
} // end function: putNode


// the thread process
void *process_job( void *parm )
{
    (void) parm;
    struct node * newNode;

    int done = 0;
    while( !done )
    {
        while(1)
        {
            if(NULL == (newNode = getNode() ) )
            {
                sleep(1);
            }

            else
            {
                break;
            }
        }

        printf( "newNode data: %s\n", newNode->data);
        free( newNode );
        if( newNode->last ) done = 1;
    }

    pthread_exit( 0 );
} // end function: process_job


struct node *getNode()
{
    pthread_mutex_lock( &jobsMutex );
    if( !jobsList )
    {
        pthread_mutex_unlock( &jobsMutex );
        return NULL;
    }

    struct node *current = NULL;

    current = jobsList;
    jobsList = jobsList->next;

    pthread_mutex_unlock( &jobsMutex );
    return current;
} // end function: getNode

以上代码产生如下输出：

newNode data: this is node:  1
newNode data: this is node:  2
newNode data: this is node:  3
newNode data: this is node:  4
newNode data: this is node:  5
newNode data: this is node:  6
newNode data: this is node:  7
newNode data: this is node:  8
newNode data: this is node:  9
newNode data: this is node:  10
newNode data: this is node:  11
newNode data: this is node:  12
newNode data: this is node:  13
newNode data: this is node:  14
newNode data: this is node:  15
newNode data: this is node:  16
newNode data: this is node:  17
newNode data: this is node:  18
newNode data: this is node:  19
newNode data: this is node:  20
newNode data: this is node:  21
newNode data: this is node:  22
newNode data: this is node:  23
newNode data: this is node:  24
newNode data: this is node:  25

您可以轻松地修改您的特定struct 定义的代码、生成结构实例的方法、在线程中接收到结构时的处理方法。