将结构内存分配给多个线程的args

Question

The following code runs mutiple threads and if a thread is already launched with the same id, it cancels the previous thread. I use this code to relaunch a timer for a light.

My problem is how to reuse thread params twice ? I must allocate memory for the struct "thread_data" before reuse and before create thread again... This can be done with through the "thread_list" map ? Maybe I'm not asking the right question... However I'm sur right answer

#include <iostream>
#include <pthread.h>
#include <sched.h>
#include <signal.h>
#include <unistd.h>
#include <map>

using namespace std;

pthread_mutex_t mutex_t;
map <string, pthread_t> thread_list;

struct thread_data
{
    char *num;
    char *type;
    int time;
};

static void cleanup(void *arg)
{
    pthread_mutex_lock(&mutex_t);
    cout << "Thread Cleaned" << endl;
    pthread_mutex_unlock(&mutex_t);
}

static void *thread(void *arg)
{
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);

    pthread_cleanup_push(&cleanup,NULL);

    thread_data* my_data = (thread_data*)(arg);
    int time = my_data->time;

    pthread_mutex_lock(&mutex_t);
    cout << "Thread start " << time << " " << my_data->num << endl << flush;
    pthread_mutex_unlock(&mutex_t);

    while(time)
    {
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
        pthread_testcancel();
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);

        sched_yield();

        pthread_mutex_lock(&mutex_t);
        sleep(1);
        time--;
        pthread_mutex_unlock(&mutex_t);
    }

    pthread_mutex_lock(&mutex_t);
    cout << "Thread End " << endl;
    pthread_mutex_unlock(&mutex_t);

    pthread_cleanup_pop(0);

    return NULL;
}

void interrupt(string num, int time = 0, string type = "")
{
    cout << "Interruptable " << num << " " << time << " " << type << endl;

    if (thread_list.find(num)->second)
    {
        cout << "Cancel " << num << endl;

        if (pthread_cancel(thread_list[num]) == 0)
        {
            pthread_detach(thread_list[num]);
            while (pthread_kill(thread_list[num], 0)==0)
                sched_yield();
        }

        thread_list.erase(num);
    }

    thread_data td;
    td.time = time;
    td.num = "Ok";

    pthread_t thread_id;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    pthread_mutex_init(&mutex_t, NULL);
    pthread_create (&thread_id, &attr, &(thread), (void *)&td);
    thread_list.insert(pair <string, pthread_t> (num, thread_id));
}

int main()
{
    cout << "Start main" << endl;

    interrupt("6335", 5, "");
    sleep(1);
    interrupt("6335", 2, "");
    sleep(6);

    cout << "End main" << endl;
    return 0;
}

Answer 1

First of all, it appears you are trying to use a structure without allocating memory for it:

 thread_data td;
 td.time = time;
 td.num = "Ok";

This code fragment would appear to me to be in error because no memory is assigned to the variable td (except the stack), yet it attempts to assign a value. Thus, once the thread is created and the function returns the memory will be corrupted. For this reason you should never use a local variable for passing data to another function. Normally, I would expect the structure to be allocated some heap memory, for example:

 thread_data td;
 td = malloc( sizeof( thread_data ) );
 if( td == NULL ) ... [error handling] ...
 td.time = time;
 td.num = "Ok";

Each time you need this structure you should allocate memory for it. Normally, (except in a specialized high-performance application) you should not attempt to re-use the memory.

Also, note that the design is flawed because there is no way to free the memory allocated for the td structure. You should actually create the td structure at a higher level, for example, in main(), then when the interrupt() function returns you should free the memory used. For example:

   main(){
     ....
     thread_data td;
     td = malloc( sizeof( thread_data ) );
     if( td == NULL ) ... [error handling] ...
     td.time = time;
     td.num = "Ok";
     interrupt( td );
     ...
     [do next interrupt]
     ...
     [after worker thread is complete]
     free( td );

or something along those lines.

Answer 2

I set "td" in "thread_data" structure. It fails after a long time....

struct thread_data
{
    int duration;
    string num;
    string type;
} td;

Complet code :

#include <iostream>
#include <pthread.h>
#include <sched.h>
#include <signal.h>
#include <unistd.h>
#include <map>

using namespace std;

pthread_mutex_t mutex_t;
map <string, pthread_t> thread_list;

struct thread_data
{
    int duration;
    string num;
    string type;
} td;

static void cleanup(void *arg)
{
    pthread_mutex_lock(&mutex_t);
    cout << "Thread Cleaned" << endl;
    pthread_mutex_unlock(&mutex_t);
}

static void *thread(void *arg)
{
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);

    pthread_cleanup_push(&cleanup,NULL);

    thread_data* my_data = (thread_data*)(arg);
    int duration = my_data->duration;

    pthread_mutex_lock(&mutex_t);
    cout << "Thread start " << duration << " " << my_data->num << endl;
    pthread_mutex_unlock(&mutex_t);

    while(duration)
    {
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
        pthread_testcancel();
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);

        sched_yield();

        pthread_mutex_lock(&mutex_t);
        sleep(1);
        duration--;
        pthread_mutex_unlock(&mutex_t);
    }

    pthread_mutex_lock(&mutex_t);
    cout << "Thread End " << endl;
    pthread_mutex_unlock(&mutex_t);

    pthread_cleanup_pop(0);

    return NULL;
}

void timer_launch(int duration, string num, string type)
{
    cout << "Interruptable " << num << " " << duration << " " << type << endl;

    if (thread_list.find(num)->second)
    {
        cout << "Cancel " << num << endl;

        if (pthread_cancel(thread_list[num]) == 0)
        {
            pthread_detach(thread_list[num]);
            while (pthread_kill(thread_list[num], 0)==0)
                sched_yield();
        }
        thread_list.erase(num);
    }

    td.duration = duration;
    td.num = num;
    td.type = type;

    pthread_t thread_id;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    pthread_mutex_init(&mutex_t, NULL);
    pthread_create (&thread_id, &attr, &(thread), (void *)&td);

    thread_list.insert(pair <string, pthread_t> (td.num, thread_id));
}

int main()
{
    cout << "Start main" << endl;

    timer_launch(5, "6335", "div");
    sleep(1);
    timer_launch(3, "6335", "div");
    sleep(6);

    cout << "End main" << endl;
    return 0;
}