programme s'écraser au hasard en raison d'appel gratuit() dans plusieurs threads

Question

j'ai un morceau de code où j'ai quelque chose comme:

int *mem_ptr; 
. 
. 
if(mem_ptr) 
{ 
    free(mem_ptr); 
} 
. 
. 

L'application est multi-thread. Parfois, ce qui se passe est un thread passe le if vérifier et puis avant le changement de contexte free() se produit et un autre thread passe également le if vérifier et également le free(). Maintenant, lorsque le contrôle revient au premier thread il se bloque à free() donnant l'erreur Abort message: 'invalid address or address of corrupt block 0x40735cb0 passed to dlfree'.

Autre que mutex, est-il une meilleure façon de gérer cette situation

PS: Je travaille sur Android classeurs natifs en C++ et ce morceau de code est dans l'appel onTransact().

Answer 1

Deux choses:

opération

1) free doit être atomique. Donc, utilisez n'importe quel mécanisme comme mutex, sémaphore, etc.

2) Après l'appel free(), mettez explicitement à jour votre pointeur vers NULL. Donc, dans le deuxième fil, il ne donnera pas if()

S'il vous plaît noter: free() appel après la mémoire de fente n'attribuera pas NULL à votre pointeur.

Answer 2

Si deux threads ou plus tentent de libérer/supprimer la même mémoire, le code et le design sont rompus. Alors que le threading des primitives de synchronisation aiderait, je ne les utiliserais pas non plus. Il devrait y avoir juste un fil libérant la mémoire. Il devrait idéalement être celui qui a alloué la mémoire. S'il est différent, comme dans le cas d'un passage de message croisé, seul le thread cible un devrait supprimer la mémoire. C'est comme dire qu'un thread ouvre un fichier et que n'importe quel thread le ferme. Ça n'a pas l'air bien. La fermeture du fichier doit être effectuée par un thread unique, et non par plusieurs threads en contention.

Answer 3

Parce que free de NULL fonctionne bien, ne rien faire, utilisez que:

int *mem_ptr(NULL); 
. 
. 
if(mem_ptr) 
{ 
    //any multithreaded lock guard have to be here 
    free(mem_ptr); 
    mem_ptr = NULL; 
} 

Alors, seule chose que vous devez prendre soin, est que les opérations free et pointeur de réglage à NULL doivent être atomiques. Cela signifie que tous les autres threads ne doivent pas effectuer ces opérations avant la fin de l'opération, ce qui signifie utiliser des objets de synchronisation de base.

Answer 4

Vous pouvez affecter le pointeur à NULL comme expliqué dans les autres réponses ... mais cela ne garantit toujours pas le succès. Deux threads peuvent passer à la fois et appeler free() l'un après l'autre, puis assigner à NULL après cela .... mais trop tard car votre programme pourrait bien avoir crashé.

Vous devez utiliser des mécanismes de synchronisation de fil ici comme un mutex:

std::mutex mtx;   // declare mutex for critical section 
    : 
    : 
mtx.lock(); // only one thread will get inside here... 
if(mem_ptr) 
{ 
    //any multithreaded lock guard have to be here 
    free(mem_ptr); 
    mem_ptr = NULL; 
} 
mtx.unlock(); // release the mutex...