Passer plusieurs arguments pour filetée fonction de pthread_create

c'est ma première tentative à l'enfilage en C. je suis entrain de créer un cercle délimité de la mémoire tampon. Je sais comment créer le thread, mais tous les exemples que j'ai vu que filetés fonctions qui acceptent un paramètre void, mais malheureusement, mon travailleur de la spécification m'oblige à utiliser les trois, comme illustré ici:

void bufferRead(BoundedBuffer* buffer, char* data, int count) {
    pthread_mutex_lock(&buffer->mutexBuffer);
    <snip>
    pthread_mutex_unlock(&buffer->mutexBuffer);
}

Voici mon pthread_create déclaration

pthread_create(&buffer.readThread, NULL, (void *)bufferRead, &readParams)

Et mon readParams struct/affectations

struct readThreadParams {                                                   
    BoundedBuffer b;                                                        
    char* data;                                                             
    int count;                                                              
};                                                                          

struct readThreadParams readParams;                                         
readParams.b = buffer2;                                                     
readParams.data = out_array;                                                
readParams.count = in_size;

Des conseils sur la façon d'attribuer à chacune des struct paramètres après le passage à la bufferRead fonction serait grandement apprécié.

OriginalL'auteur ChrisDevWard | 2013-04-26

c posix pthreads

8

C'est parce que vous ne vraiment besoin un paramètre. Quand nous avons plus d'une valeur, comme c'est généralement le cas, nous encapsuler dans une struct. Le type de fonction que pthread_create fera appel est non-négociable. C'est un domaine où le type coulée de votre pointeur de fonction peut vous causer des ennuis.
```
#include <pthread.h>
#include <stdlib.h>

struct BoundedBuffer {
    pthread_t readThread;
    pthread_mutex_t mutexBuffer;
} buffer2;

struct readThreadParams {
    struct BoundedBuffer b;
    char* data;
    int count;
};

void *bufferRead (void *context) {
    struct readThreadParams *readParams = context;

    pthread_mutex_lock(&readParams->b.mutexBuffer);
    //<snip>
    pthread_mutex_unlock(&readParams->b.mutexBuffer);

    return NULL;
}

int main(void) {
    int ret;
    char *out_array = malloc(42);
    size_t in_size = 42;

    struct readThreadParams readParams;
    readParams.b = buffer2;
    readParams.data = out_array;
    readParams.count = in_size;

    /* I presume that by "buffer", you really meant the .b member of
     * struct readThreadParams.  Further, this must have a member
     * named readThread of type pthread_t, etc.
     */
    ret = pthread_create(&readParams.b.readThread, NULL, bufferRead, &readParams);

    if (!ret) {
        pthread_join(&readParams.b.readThread, NULL);
    }

    free(out_array);

    return ret;
}
```
-1 en passant une variable locale à un autre thread
Si c'est une variable locale principal qui n'est pas un problème. Si vous fermez la fenêtre principale, puis votre programme se termine de toute façon si la variable existe toujours alors que votre programme est en cours d'exécution.
Laissant main ne veut pas dire immédiate de fin de programme. Et automatique (non-tas, non statique) de la variable pour la communication inter-thread est une idée discutable, au mieux.
Ok vous avez raison, il y a un petit intervalle entre la fin principale et l'exécution de sortie. Donc, il n'est pas sûr. Je suis d'accord. J'allais écrire quelque chose à propos de la façon dont, aussi longtemps que vous créez votre objet thread après la variable locale vous passez en vous garantit d'être en sécurité, mais c'est c/pthreads, pas du c++ que j'ai d'abord pensé.
L'OP code ne fait aucune mention de main(). À l'aide d'une pile locale struct comme un paramètre est très dangereux dans le cas général de la non-trivial apps.

OriginalL'auteur Daniel Santos

Fonction de démarrage doit prendre en argument. Si votre direction est droite:

struct readThreadParams {                                                   
    BoundedBuffer *b; 
    char *data;                                                             
    int count;                                                              
};

Ensuite, vous avez besoin d'allouer de la variable sur le tas, pas sur pile:

struct readThreadParams *readParams;

readParams = malloc(sizeof(*readParams));
readParams->b = buffer2;                                                     
readParams->data = out_array;                                                
readParams->count = in_size;

Après quoi vous pouvez lui donner createThread:

pthread_create(&buffer.readThread, NULL, bufferRead, readParams);

Fonction de Thread prend seulement 1 argument (void*):

void *bufferRead(void *arg)
{
    struct readThreadParams *params = arg;
    BoundedBuffer *buffer = params->b;
    char* data = params->data;
    int count = params->count;

    pthread_mutex_lock(&buffer->mutexBuffer);
    <snip>
    pthread_mutex_unlock(&buffer->mutexBuffer);

    return NULL;
}

OriginalL'auteur Valeri Atamaniouk

1

Vous avez obtenu dans le droit chemin.

Le prototype de fonction devrait être comme
```
void*  bufferRead(void *arg)
{
   ....
}
```
Et transtypage de l'argument de type requis en fonction de thread. Ici, il convient de
```
void*  bufferRead(void *arg)
{
     struct readThreadParams *input = (struct readThreadParams*)arg;
}
```
Passant plus d'un argument à la fonction pthread n'est pas possible directement. donc, le plus souvent formé en tant que structure et transmis à la fonction.

Reportez-vous cette tutoriel pour plus de détails sur les pthreads.

Merci pour la réponse rapide! Demandais juste, mais est-il possible de toujours utiliser le prototype de fonction j'ai actuellement?
vous pouvez transtypage et de créer. Mais pas d'utilisation. donc void * ()(void*) est recommandé.
Non, vous ne pouvez pas. Eh bien, la seule façon d'utiliser ce prototype est d'appeler directement à partir de votre void *start_routine(void *) fonction que la bibliothèque pthread appeler, mais ce serait inutilement introduire la surcharge d'un autre appel de fonction.
Aussi, le transtypage de void* vers un autre type de pointeur n'est pas strictement nécessaire (je ne suis pas sûr de ce que C normes ce peut être requis), mais à partir d'un autre pointeur de type void* nécessite un type explicite exprimés.
Un transtypage de void * peuvent être convertis à un pointeur vers un objet de type, et de retour à nouveau, et la valeur doit convertir l'égalité. C'est en tous C normes, autant que je sache. Les Aspects de comportement indéfini existe si vous tentez d'accéder à l'objet vers lequel il pointe, et le pointeur n'est pas aligné correctement pour stocker ce type, ou si elle ne pointe pas vers un objet d'une taille appropriée, ou à la représentation.

OriginalL'auteur Jeyaram

Cet exemple frontières sur le préprocesseur d'abus, mais je l'aime parce qu'il démontre imitant la valeur par défaut des arguments.

#include <assert.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef char *BoundedBuffer;

struct read_thread_param {  
    pthread_t thread;                                                 
    BoundedBuffer buffer;                                                        
    char* data;                                                             
    int count;                                                              
}; 

void buffer_read(BoundedBuffer* buffer, char* data, int count) {
    pthread_mutex_lock(&buffer->mutexBuffer);
    /*snip*/
    pthread_mutex_unlock(&buffer->mutexBuffer);
}

void *buffer_read_entrance(void *object) {
    struct read_thread_param *param = object;
    if (param->thread != 0) {
        buffer_read(&param->buffer, param->data, param->count);
        free(param);
        return NULL;
    }

    param = malloc(sizeof *param);

    /* TODO: Handle allocation error */
    assert(param != NULL);

    memcpy(param, object, sizeof *param);

    /* TODO: Handle thread creation error */
    assert(pthread_create(&param->thread, NULL, buffer_read_entrance, param) == 0);
    return NULL;
}

#define buffer_read_entrance(...) buffer_read_entrance(&(struct read_thread_param) { .thread = 0, __VA_ARGS__ })
void buffer_read(BoundedBuffer* buffer, char* data, int count);

int main(void) {
    buffer_read_entrance(.buffer = "hello world", .count = 42);
}

OriginalL'auteur autistic

Vous devez vous connecter pour publier un commentaire.