pasar estructuras como argumentos durante el uso de pthread_create()

Question

he intentado hacer pasar una estructura que el cuarto argumento al utilizar pthread_create() con algo como esto:

pthread_create(&tid1, NULL, calca, &t); //t is the struct 

Ahora cada vez que intento acceder a las variables de la estructura - ta, tb o tc, sigo recibiendo un error: solicitud de miembro en algo que no es una estructura o unión.

¿Qué método alternativo podría usar para pasar estructuras al hilo?

Answer 1

Probablemente esté creando la estructura en el mismo ámbito que pthread_create. Esta estructura ya no será válida una vez que se abandone el alcance.

Intente crear un puntero a la estructura en el montón y pase ese puntero de estructura a su hilo. No olvides borrar ese recuerdo en algún lugar (en el hilo si nunca volverás a usarlo, o cuando ya no lo necesites).

Además, como se mencionó en cyberconte, si va a acceder a esa información desde diferentes subprocesos, deberá bloquear el acceso a ella con una exclusión mutua o sección crítica.

Editar 14 de mayo de 2009 a las 12:19 pm EST: Además, como han mencionado otras personas, debe convertir su parámetro al tipo correcto.

Si estás pasando una variable que es una estructura global (que usted parece estar insistiendo en), su función del hilo tendrá que echar al tipo:

void my_thread_func(void* arg){ 
    my_struct foo = *((my_struct*)(arg)); /* Cast the void* to our struct type */ 
    /* Access foo.a, foo.b, foo.c, etc. here */ 
} 

O, si estás de paso una Puntero a su estructura:

void my_thread_func(void* arg){ 
    my_struct* foo = (my_struct*)arg; /* Cast the void* to our struct type */ 
    /* Access foo->a, foo->b, foo->c, etc. here */ 
} 

Answer 2

Puede utilizar la memoria compartida o una variable global (si nada más necesita ese argumento) o una lista vinculada si estos son hilos que se alimentan de datos.

Solo recuerda bloquear las variables que se están compartiendo.

Sin embargo, sin el código ofensivo actual, no puedo decirte lo que estás haciendo mal en tu implementación actual.

Answer 3

Si está dentro de la función de subprocesos, el argumento que aprueba es nulo *. Tendrás que convertirlo en una estructura antes de poder usarlo como tal.

void my_thread_func(void* arg){ 
    my_struct foo = (my_struct)(*arg); /* Cast the void* to our struct type */ 
    /* Access foo.a, foo.b, foo.c, etc. here */ 
} 

Answer 4

Este mensaje de error significa que no está desreferenciando el puntero.

Estás diciendo "ta" en lugar de "t> a"

 
[me@myhost ~]$ cat testitx.c 
struct x { 
     int a, b; 
}; 

int main(int argc, char *argv[]) 
{ 
     struct x y, *z; 

     z = &y; 
     z.a = 10; 
} 
[me@myhost ~]$ cc -c testitx.c 
testitx.c: In function `main': 
testitx.c:10: error: request for member `a' in something not a structure or union 
[me@myhost ~]$ 

Answer 5

A menudo solía cometer los mismos errores que figuran en las otras respuestas, pero ahora tomo un enfoque ligeramente diferente que se mueve el potencial de error de la función de subprocesamiento a la llamada pthread_create.

Declaro y definir la función de enhebrado de una manera 'normal':

void *ThreadFunction(sPARAMETERS *Params) { 

    // do my threading stuff... 

} 

y cuando llamo pthread_create, necesito usar un yeso:

pthread_create(&ThreadId,0,(void*(*)(void*)) &ThreadFunction,&Params); 

casi nunca olvido use el & en los Params, y el compilador se encargará de cualquier error que yo haga en el otro extremo. Funciona muy bien para callbacks, también.

Answer 6

1. Crear un semáforo

2. Crear otra estructura que consta de un puntero a la estructura y el mango de semáforos

3. pasar un puntero a esta nueva estructura a pthread_create

4. En el hilo padre, es decir, aquel llamado pthread_create, espera en el semáforo

5. En el hilo hijo, copie los miembros de su estructura a las variables locales o guardarlos en otro lugar

6. En el hilo hijo, la señal del semáforo

7. En el hilo de los padres, cerrar el semáforo

Answer 7

my_struct foo = (my_struct) (* arg); es incoreect try my_struct * foo = (my_struct *) (arg);
Y, en la función Llamar al hilo, asegúrese de que sea estático (de modo que la memoria apuntada no se pierda en la niebla)