L'annulation des threads

Bonjour !

pourriez vous me dire ce que fait cette fonction et précisément les fonctions qui se trouvent a l'interieur de la fonction .
Code:

1 2 3 4 5 6 7 8 9 10 void * thd4 (void *y) { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); while (compt[3]<100000000) compt[3]++; pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); while (compt[3]<200000000) compt[3]++; }

Bonjour,

Lorsque l'on ne connait pas une fonction, on regarde sa documentation. Sous Linux, on peut utiliser la commande :

Citation:

man nom_de_la_fonction

Mais, heureusement, notre « ami » Google comprend aussi cette recherche et retourne un résultat sensiblement identique.

La première commande désactive le fait que le thread soit annulable. Il ne pourra pas être stoppé par un autre thread.
La seconde commande fait que le thread pourra être annulé à n'importe quel moment.

Je vous remercie de m'avoir répondu

Biensure que je suis passé chez Mr Google avant de poster ce message ;)
j'ai jeté un oeil sur la documentation et je l'ai presque compris .

mais le probleme c'est lors de l'execution de cette fonction le thread aura pour valeur 2000000 pourtant avant d'evaluer la boucle2 on a appelé la fonction pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL) ce qui veut dire que normalement la boucle 2 ne sera pas executé puisque que le thread sera annulé immediatement .

Je loupe peut être quelque chose, mais pourquoi sera t-il annulé directement ?

1 pièce(s) jointe(s)

sincerement je n'ai aucune idée je ne sais pas pourquoi il execute la 2eme boucle .
voici le screenshot de l'execution c'est le dernier compteur qui vaut 2000000.

Pièce jointe 194524

c'est un tp a rendre demain c'est le dernier.
Je vous serais très reconnaissant si vous pouviez m'aider.

Et il n'y a aucune raison que le thread s'arrête. Certes vous avez changer son état pour qu'il soit annulable, toutefois, vous ne faites aucun ordre d'annulation (avec pthread_cancel() dans le thread parent). Donc, le thread, n'ayant aucun ordre de s'annuler, ne s'annule pas et continue tranquillement son travail.

Note : heureusement que les threads ne s'arrête pas sans raison et inopinément :aie:.

mais on a envoyé un orde d annulation dans le main a tous les thread

Dans ce cas là, remettre :

Code:

pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

Bonjour,

Un thread est normalement type PTHREAD_CANCEL_DEFERRED et state PTHREAD_CANCEL_ENABLED, ce qui signifie qu'un cancel ne sera pris en compte qu'au moment où il est dans une fonction dite 'cancel point'. Ceci permet de ne pas tuer un thread pendant une action potentiellement critique.
Ce principe est le plus souvent suffisant.

En changeant son type en PTHREAD_CANCEL_ASYNCHRONOUS, il protège ses phases sensibles par des séquences :

PTHREAD_CANCEL_DISABLED
... traitement protégé ...
PTHREAD_CANCEL_ENABLED
... traitement interruptible sans risque ...
PTHREAD_CANCEL_DISABLED
... traitement protégé ...

Bonjour
Je pense qu'il faut lire le code-t-elle qu'il est écrit et non comme ce que l'on a voulue écrire, car un programme fait toujours ce qui est écrit, pas nécessairement ce que l'on a souhaité qu'il fasse.

Citation:

Envoyé par Naswd_94

Bonjour !
pourriez vous me dire ce que fait cette fonction et précisément les fonctions qui se trouvent a l'interieur de la fonction .

Code:

1
2
3
4
5
6
7
8
9
10
 
 void * thd4 (void *y)
 {
  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
  while (compt[3]<100000000) 
  compt[3]++;
  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
  while (compt[3]<200000000) 
  compt[3]++;
 }

La première instruction pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); ignore toute requête d'annulations en clair, le thread ne peut être arrêté et de ce fait la boucle tant que fait ce qu'il a à faire, cela est dû au masque PTHREAD_CANCEL_DISABLE que vous avez mis en place.
La seconde instruction qui vient juste après la boucle tant que permet d'annuler le thread appelant dès que possible en recevant les cancels a n'importe quel moment donc (de façon asynchrone) sauf que vous avez omis de démasquer les cancels. En clair, vous avez oublié de préciser que l'on peut accepter les cancels à nouveaux (PTHREAD_CANCEL_ENABLED) et c'est donc tout à fait normal que le code qui suit après cette instruction soit exécuté, car on ignore toujours tout souhait d'arrêt d'exécution.

/!\Exemple d'un teste à revoir car le code source ci-dessous est susceptible de comporter des erreurs

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
int iTab_Compteur[] = {
	0, 0, 0, 0 };
 
void *f_Thread_A(void*);
void *f_Thread_B(void*);
void *f_Thread_C(void*);
void *f_Thread_D(void*);
void *f_Thread_E( void *);
 
void *f_Thread_A( void *pData ){
		pData = NULL;
		fprintf( stdout,"[\tA\t]Thread A s'exécute et peut s'arrêter à tout moment\n");
		pthread_testcancel();
		while( iTab_Compteur[0] < INTMAX_MIN ){
			pthread_testcancel();
			iTab_Compteur[0]++;
		}
		pthread_testcancel();
		fprintf( stderr,
			"\nErreur Critique-> [\tA\t] -> Si y a Cancel normalement je m'exécute pas !!\n" );
		return NULL;
}
 
void *f_Thread_B( void *pData ){
	pData = NULL;
	fprintf( stdout,"[\tB\t]Thread B s'exécute .....\n");
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL );
	pthread_testcancel();
	fprintf( stdout,"[\tB\t]Thread B s'exécute et j'ignore tout cancel \n");
	pthread_testcancel();
	while( iTab_Compteur[1] < INTMAX_MIN ){
		pthread_testcancel();
		iTab_Compteur[1]++;
	}
	pthread_testcancel();
	fprintf( stderr,
			 "[\tB\t] -> il y a cancel normalement je m'exécute par maïs ici je l'ignore !!\n");
	return NULL;
}
 
void *f_Thread_C( void *pData ){
	pData = NULL;
	fprintf( stdout,"[\tC\t]Thread C s'exécute .....\n");
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
	fprintf( stdout, "[\tC\t]Thread C s'exécute toujours et j'arrête à tout moment\n");
	pthread_testcancel();
	while( iTab_Compteur[2] < INTMAX_MIN ){
		pthread_testcancel();
		iTab_Compteur[2]++;
	}
	pthread_testcancel();
	fprintf( stderr, 
		"\nErreur Critique->[\tC\t] -> Si y a cancel normalement j'exécute pas cette ligne!!\n" );
	return NULL;
}
 
void *f_Thread_D( void *pData ){
	pData = NULL;
	fprintf( stdout,"[\tD\t]Thread D s'exécute......\n");
	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
	fprintf( stdout, "[\tD\t]thread D s'exécute encore et je ne m'arrête qu'après traitement\n");
	while( iTab_Compteur[3] < INTMAX_MIN ){
		pthread_testcancel();
		iTab_Compteur[3]++;
	}
	pthread_testcancel();
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
	fprintf( stdout, "[\tD\t]Thread D s'exécute toujours mais j'ignore plus les cancels \n");
	pthread_testcancel();
	while( iTab_Compteur[3] < INTMAX_MIN ){
		pthread_testcancel();
		iTab_Compteur[3]--;
	}
	fprintf( stdout,"[\tD\t]Thread D s'exécute prend en compte tout cancel \n");
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
	pthread_testcancel();
	fprintf( stdout, "[\tD\t]Thread D s'exécute toujours et je peux m'arrêter à tout moment\n");
	while( iTab_Compteur[3] < INTMAX_MIN )
		iTab_Compteur[3]++;
 
	fprintf( stderr, "\nErreur Critique->[\tD\t] -> Si y a cancel normalement je m'exécute pas !!\n" );
	return NULL;
}
 
void *f_Thread_E( void *pData ){
	pData = NULL;
	fprintf( stdout,"[\tE\t]Thread E s'exécute ... \n");
	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
		NULL);
	fprintf( stdout,"[\tE\t]Thread E s'exécute et j'ignore tout cancel \n");
	fprintf( stdout, "[\tE\t]Thread E s'exécute et je ne m'arrête qu'après traitement\n");
	while( iTab_Compteur[4] < INTMAX_MIN )
			iTab_Compteur[4]++;
	fprintf( stdout,"[\tE\t]Thread E s'exécute encore et j'ignore tout cancel \n");
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,
		NULL);
 
	fprintf( stdout, "[\tE\t]Thread E s'exécute et peut s'arrêter à tout moment \n");
	pthread_testcancel();
	while( iTab_Compteur[4] < INTMAX_MIN )
		iTab_Compteur[4]--;
	fprintf( stderr, "\nErreur Critique -> [\tE\t] -> Si y a cancel normalement je m'exécute pas !!\n" );
}
 
 
 
int main( void ){
 
	int i = 0;
	pthread_t tab_thread[5];
	const int inb_thread = 4;
 
	pthread_create( &tab_thread[0], 0, f_Thread_A, (void*)i );
	pthread_create( &tab_thread[1], 0, f_Thread_B, (void*)i );
	pthread_create( &tab_thread[2], 0, f_Thread_C, (void*)i );
	pthread_create( &tab_thread[3], 0, f_Thread_D, (void*)i );
	pthread_create( &tab_thread[4], 0, f_Thread_E, (void*)i );
 
 
	for( i = 0; i < inb_thread; i++ )
		pthread_cancel(tab_thread[i]);
 
	for( i = 0; i < inb_thread; i++ )
		pthread_join(tab_thread[i], NULL );
 
	fprintf( stdout, "======\n" );
	for( i = 0; i < 5; i++ )
		fprintf( stdout, "Thread[%c]\t:%d\n",
			(i == 0) ? 'A' : (i == 1) ? 'B': (i == 2) ? 'C' : (i == 3) ? 'D': 'E' );
	return EXIT_SUCCESS;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
[	A	]Thread A s'exécute et peut s'arrêter à tout moment
[	B	]Thread B s'exécute .....
[	C	]Thread C s'exécute .....
[	D	]Thread D s'exécute......
[	E	]Thread E s'exécute ... 
[	C	]Thread C s'exécute toujours et j'arrête à tout moment
[	D	]thread D s'exécute encore et je ne m'arrête qu'après traitement
[	E	]Thread E s'exécute et j'ignore tout cancel 
[	D	]Thread D s'exécute toujours mais j'ignore plus les cancels 
[	E	]Thread E s'exécute et je ne m'arrête qu'après traitement
[	E	]Thread E s'exécute encore et j'ignore tout cancel 
[	E	]Thread E s'exécute et peut s'arrêter à tout moment 
 
Erreur Critique -> [	E	] -> Si y a cancel normalement je m'exécute pas !!
======
Thread[A]	:3331
Thread[B]	:3587
Thread[C]	:3843
Thread[D]	:4099
Thread[E]	:4355

à bientôt

Citation:

LittleWhite

Citation:

dalfab

Citation:

sambia39

je vous remercie pour votre aide !
a bientot :)