Impossible d'annuler mes threads

Bonjour à tous voilà je créé mon pool de thread

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
pthread_t *Clients = NULL;
 
int main(int argc,char *argv[])
{
Clients = (pthread_t *)malloc(max_threads * sizeof(pthread_t));
pthread_create(&ThreadStop,NULL,(void *(*)(void *))Thread_Stop,NULL);
    pthread_detach(ThreadStop);
        for(int i = 0;i<max_threads;i++)
        {
            pthread_create(&Clients[i],NULL,(void *(*)(void *))Thread_Client,NULL);
            pthread_detach(Clients[i]);
        }      
}

Chaque thread exécute la fonction suivante

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void Thread_Client()
{
    pthread_cleanup_push(Cleanup_Client,0);
    int rc;
 
    if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,&rc))
    {
        perror("");
        exit(1);
    }
 
    if(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&rc))
    {
        perror("");
        exit(1);
    }  
    cout << "(Thread client) en attente" << endl;
    pthread_mutex_lock(&MutexThreadClient);
    pthread_cond_wait(&CondThreadClients,&MutexThreadClient);
    pthread_mutex_unlock(&MutexThreadClient);
    cout << "(Thread client) start" << endl;
    pthread_cleanup_pop(1);
}

J'ai un thread STOP qui a pour role d'annuler mes threads client

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
void Thread_Stop()
{
    struct sigaction action;
    sigset_t mask;
 
    sigemptyset(&mask);
    sigaddset(&mask,SIGALRM);
    sigaddset(&mask,SIGINT);
    sigprocmask(SIG_SETMASK,&mask,NULL);
 
    sigemptyset(&action.sa_mask);
    action.sa_handler = Handler_Stop;
    action.sa_flags = SA_SIGINFO;
    sigaction(SIGALRM,&action,NULL);
    sigaction(SIGINT,&action,NULL);
 
    cout << "(Thread_Stop) en attente..." << endl;
    pthread_mutex_lock(&MutexThreadStop);
    pthread_cond_wait(&CondThreadStop,&MutexThreadStop);
    pthread_mutex_unlock(&MutexThreadStop);
    cout << "(Thread_Stop) reveille !" << endl;
 
    pthread_mutex_lock(&MutexDelay);
    alarm(delay);
    pthread_mutex_unlock(&MutexDelay);
    cout << "delay de" << delay << " seconde(s) " << endl;
    //pause();
 
    for(int i = 0;i<max_threads;i++)
    {
        pthread_cancel(Clients[i]);
    }
 
    cout << "* (Thread_Stop) Fin du ThreadStop *" << endl;
    trace << "* (Thread_Stop) Fin du ThreadStop *";
}

Dès que je fait un ctrc + C, je réveille mon thread STOP

Code:

1
2
3
4
5
6
7
void Handler_Stop(int signal)
{
    cout << "(Handler_Stop) Signal :" << signal << endl;
    pthread_cond_signal(&CondThreadStop);
 
 
}

Pensant que les threads clients seront belle et bien correctement arrêté, mais non ma fonction de terminaison n'est exécuté qu'une seule fois par qu'un seul thread client... :cry:

Code:

1
2
3
4
void Cleanup_Client(void *p)
{
    cout << "* (Thread_Client) Fin d'un Thread_Client *" << endl;
}

Une idée ?

Merci d'avance