probleme avec pthread_cancel

Version imprimable

04/05/2009, 11h01
Rhapso59

probleme avec pthread_cancel

bonjours je fais un programme qui crée un thread et un qui le supprime avec pthread_cancel je les ai lié par un tube nomé dans leque jenvoi le pthread_t
et ca ne fonctionne pas pourtant je recois correctement le pthread_t. Esce que c'est un probleme a cause de la structure de pthread_t ? ou autre chose ?

merci d'avance
04/05/2009, 13h52
nicolas.sitbon

montre nous le code.

Anti zombie

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
 
#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include "initialisation.h"
#include <locale.h>
#include <pthread.h>
#include <locale.h>
 
int main(void)
{
 
char buffer[15];
long threadt;
char TubeNommeZBI[TAILLE_NOM_FIFO]="TUBZBI";
 
pthread_t threadrecu;
while(1) //boucle infini
	{
	//ouvertue de tube
	if((TubeZBI_fd = open(TubeNommeZBI, O_RDWR )) < 0)
		{
		fprintf(stderr,"erreur d'ouverture du tube nomme %s\n",TubeNommeZBI);
		exit(EXIT_FAILURE);
		}
 
	fd_set rfds;
	struct timeval tv;
	int retval;
	//intialisation buffer
	memset(buffer,'\0',sizeof(buffer));
 
	FD_ZERO(&rfds);
	FD_SET(TubeZBI_fd, &rfds);
	// Ecouter pendant 5 seconde
	tv.tv_sec = 1;
	tv.tv_usec = 0;
	printf("Ecoute pendant 5 secondes, TubeZBI_fd=%d\n",TubeZBI_fd);
	retval = select(TubeZBI_fd+1, &rfds, NULL, NULL, &tv);
 
	if (retval)
		{
		// Lire le tube
		if (read(TubeZBI_fd, buffer,sizeof(pthread_t))==-1)
			{
			printf("erreur d'écriture du tube nomme\n");
			exit(EXIT_FAILURE);
			}
		close(TubeZBI_fd);
		memcpy(&threadrecu,(pthread_t *) buffer,sizeof(pthread_t));
 
//		fprintf (stdout, "threadt : %s ln:%d\n", buffer,strlen(buffer));
 
		pthread_t threadrecu;
		fprintf (stdout, "Threadt : %ld\n", threadrecu);
 
 
		//Suppression thread
 
		if (pthread_cancel(threadrecu)==0)
			{
			///Listage
			}
 
		}
	else
		{
		puts("Pas de thread");
		}
	}
return (0);
}

zombie

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
 
 
 
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include "initialisation.h"
#include <locale.h>
static void *task_a (void *p_data)
{
char buffer[7];
//char endbuf[8];
 
printf("theard activé debut de temporisation"); 
//Temporisation simulation "Zombie"
sleep(5);
//Fin temporisation
puts("fin de temporisation");
// Ecrire du endPID dans le tube nommé
 
sleep(5);
(void) p_data;
return NULL;
}
 
int main (void)
{
char buffer[20];
char TubeNommeZBI[TAILLE_NOM_FIFO]="TUBZBI";
pthread_t ta;
puts ("theard initialisé");
//Fonction d'Initialisation des pipes
if(open(TubeNommeZBI,O_RDWR | O_NONBLOCK))
	{
	unlink(TubeNommeZBI);
	}
//Création des Pipes Nommés. On teste si la création a échoué. Si oui, renvoie l'erreur et arrêt du programme.
if(mkfifo(TubeNommeZBI,0644) == -1)
	{	
	fprintf(stderr,"erreur de creation du tube nommé %s \n ",TubeNommeZBI);
	exit(EXIT_FAILURE);
	}
//Ouverture des Pipes Nommés. On teste si l'ouverture a réussi. Si non, renvoie une erreur et arrêt du programme
if((TubeZBI_fd = open(TubeNommeZBI, O_RDWR )) < 0)
	{
	fprintf(stderr,"erreur d'ouverture du tube nommé %s\n",TubeNommeZBI);
	exit(EXIT_FAILURE);
	}
 
printf("ta: %d\n", ta);
pthread_create (&ta, NULL, task_a, NULL);
printf("ta: %d\n", ta);
if (write(TubeZBI_fd, &ta,sizeof(pthread_t))==-1)
	{
	printf("erreur d'écriture du tube nommé\n");
	exit(EXIT_FAILURE);
	}
 
 
 
 
//close(TubeZBI_fd);
//Synchronisation du thread
pthread_join (ta, NULL);
//Fin thread
puts ("fin theard");
return 0;
}

j'ai modifié quelque truc toujours le même probleme

Antizombie.c

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
 
#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include "initzombie.h"
#include <locale.h>
#include <pthread.h>
#include <locale.h>
#define TAILLE_BUFFER 15
 
int main(void)
{
// Tableau Date
 
char buffer[TAILLE_BUFFER]={0};
char TubeNommeZBI[TAILLE_NOM_FIFO]="TUBZBI";
pthread_t threadrecu;
 
while(1) //boucle blanche
	{
	threadrecu=0;
	//ouvertue de tube
	if((TubeZBI_fd = open(TubeNommeZBI, O_RDWR )) < 0)
		{
		fprintf(stderr,"erreur d'ouverture du tube nomme %s\n",TubeNommeZBI);
		exit(EXIT_FAILURE);
		}
 
	fd_set rfds;
	struct timeval tv;
	int retval;
 
 
	FD_ZERO(&rfds);
	FD_SET(TubeZBI_fd, &rfds);
	// Ecouter pendant 5 seconde
	tv.tv_sec = 2;
	tv.tv_usec = 0;
	printf("Ecoute pendant 2 secondes, TubeZBI_fd=%d\n",TubeZBI_fd);
	retval = select(TubeZBI_fd+1, &rfds, NULL, NULL, &tv);
 
	if (retval)
		{
		// Lire le tube
		if (read(TubeZBI_fd, buffer,sizeof(pthread_t))==-1)
			{
			printf("erreur de lecture du tube nomme\n");
			exit(EXIT_FAILURE);
			}
		close(TubeZBI_fd);
		memcpy(&threadrecu,(pthread_t *) buffer,sizeof(pthread_t));	
 
		fprintf (stdout, "Threadt : %ld, taille:%d\n", threadrecu, sizeof(threadrecu));
 
		//Suppression thread
		pthread_testcancel();
		if (pthread_cancel(threadrecu)==0)//pthread cancel ne marche pas bordel a chiote de merde!!!
			{
			puts("Thread supprimé");
			void ecrireTxt(long threadrecu);
			}
		else
			{
			puts("Echec lors de la supression du thread");
			}
		pthread_testcancel();
		}
	else
		{
		puts("Pas de thread");
		}
	}
return (0);
}
 
 
void ecrireTxt(long id)
{
}

zombie.c

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
 
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include "initzombie.h"
#include <locale.h>
static void *task_a (void *p_data)
{
long va;
printf("theard activé debut de temporisation"); //ta=%d",ta);
va=pthread_self();
printf("va: %d\n", va);
//Temporisation simulation "Zombie"
sleep(5);
//Fin temporisation
puts("fin de temporisation");
 
(void) p_data;
return NULL;
}
 
int main (void)
{
 
 
char TubeNommeZBI[TAILLE_NOM_FIFO]="TUBZBI";
pthread_t ta;
puts ("theard initialisé");
//Fonction d'Initialisation des pipes
if(open(TubeNommeZBI,O_RDWR | O_NONBLOCK))
	{
	unlink(TubeNommeZBI);
	}
//Création des Pipes Nommés. On teste si la création a échoué. Si oui, renvoie l'erreur et arrêt du programme.
if(mkfifo(TubeNommeZBI,0644) == -1)
	{	
	fprintf(stderr,"erreur de creation du tube nommé %s \n ",TubeNommeZBI);
	exit(EXIT_FAILURE);
	}
//Ouverture des Pipes Nommés. On teste si l'ouverture a réussi. Si non, renvoie une erreur et arrêt du programme
if((TubeZBI_fd = open(TubeNommeZBI, O_RDWR )) < 0)
	{
	fprintf(stderr,"erreur d'ouverture du tube nommé %s\n",TubeNommeZBI);
	exit(EXIT_FAILURE);
	}
 
//Creation d'un thread
 
pthread_create (&ta, NULL, task_a, NULL);
printf("ta: %d\n", ta);
 
if (write(TubeZBI_fd, &ta,sizeof(pthread_t))==-1)
	{
	printf("erreur d'écriture du tube nommé\n");
	exit(EXIT_FAILURE);
	}
 
//Synchronisation du thread
pthread_join (ta, NULL);
//Fin thread
puts ("fin theard");
return 0;
}

biblio

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
 
ifndef __INITIALISATION_H
#define __INITIALISATION_H
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/select.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <stropts.h>
#include <poll.h>
#include <signal.h>
#include <dirent.h>
#include <fnmatch.h>
 
#define TAILLE_NOM_FIFO 48
 
int shm;
 
int TubeZBI_fd;
 
#endif