IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

POSIX C Discussion :

probleme avec pthread_cancel


Sujet :

POSIX C

  1. #1
    Futur Membre du Club
    Profil pro
    Inscrit en
    Avril 2009
    Messages
    7
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2009
    Messages : 7
    Points : 6
    Points
    6
    Par défaut 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

  2. #2
    Membre émérite Avatar de nicolas.sitbon
    Profil pro
    Inscrit en
    Août 2007
    Messages
    2 015
    Détails du profil
    Informations personnelles :
    Âge : 40
    Localisation : France

    Informations forums :
    Inscription : Août 2007
    Messages : 2 015
    Points : 2 280
    Points
    2 280
    Par défaut
    montre nous le code.
    "The quieter you become, the more you are able to hear"
    "Plus vous êtes silencieux, plus vous êtes capable d'entendre"

  3. #3
    Futur Membre du Club
    Profil pro
    Inscrit en
    Avril 2009
    Messages
    7
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2009
    Messages : 7
    Points : 6
    Points
    6
    Par défaut
    Anti zombie

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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;
    }

  4. #4
    Futur Membre du Club
    Profil pro
    Inscrit en
    Avril 2009
    Messages
    7
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2009
    Messages : 7
    Points : 6
    Points
    6
    Par défaut
    j'ai modifié quelque truc toujours le même probleme

    Antizombie.c

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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

Discussions similaires

  1. Probleme avec la copie des surfaces
    Par Black_Daimond dans le forum DirectX
    Réponses: 3
    Dernier message: 09/01/2003, 11h33
  2. Problèmes avec le filtrage des ip
    Par berry dans le forum Réseau
    Réponses: 9
    Dernier message: 30/12/2002, 08h51
  3. probleme avec la touche F10
    Par b.grellee dans le forum Langage
    Réponses: 2
    Dernier message: 15/09/2002, 23h04
  4. Probleme avec fseek
    Par Bjorn dans le forum C
    Réponses: 5
    Dernier message: 04/08/2002, 08h17
  5. [Kylix] probleme avec un imagelist
    Par NicoLinux dans le forum EDI
    Réponses: 4
    Dernier message: 09/06/2002, 00h06

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo