Dans mon programme j'utilise un systeme producer–consumer avec une std::queue
Dans le thread je peut faire appel a chunksToLoad.pop(); par exemple mais pas à chunksToLoad.front(); qui fait crash
Dans mon programme j'utilise un systeme producer–consumer avec une std::queue
Dans le thread je peut faire appel a chunksToLoad.pop(); par exemple mais pas à chunksToLoad.front(); qui fait crash
Bonjour,
Il nous faut plus d'info pour pouvoir t'aider.
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 #include "chunkLoading.h" #include "iostream" #include <SFML/Window.hpp> #include<chunk.h> using namespace std; ChunkLoading::ChunkLoading() { } ChunkLoading::ChunkLoading(World* world) { worldIn=world; for(int i=0;i<5;i++) for(int j=0;j<1;j++) for(int k=0;k<5;k++) { addChunkToLoad(ivec3(i,j,k)); } thread loadingThread(loadLoop,this); loadingThread.detach(); } ChunkLoading::~ChunkLoading() { //dtor } void ChunkLoading::loadChunk() { if(!chunksToLoad.empty()) { glm::ivec3 pos=chunksToLoad.front();//crash Chunk* p = new Chunk(pos,worldIn); worldIn->queueMutex.lock(); worldIn->sendChunk(p); worldIn->queueMutex.unlock(); chunksToLoad.pop(); } } void ChunkLoading::loadLoop() { while(!chunksToLoad.empty()) { sf::sleep(sf::milliseconds(100)); loadChunk(); } }
Il manque encore des infos. D'après ce que je vois. A quoi ça sert un mutex? Ça permet d’empêcher que 2 threads agissent en même temps sur une même ressource. Ta fonction loadChunk() veut protéger l'appel à sendChunk(), c'est possible que ça soit nécessaire, j'ai des doutes (divination sans voir le code). Par contre l'objet chunkToLoad est peut-être utilisé par plusieurs threads (divination sans voir le code), et dans ce cas il faut "protéger" les fonctions qui l'utilisent comme .empty() .front() et .pop(). Du coup, je "protégerais" exactement l'inverse de ce que tu as fait.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12 void ChunkLoading::loadChunk() { worldIn->queueMutex.lock(); if ( !chunksToLoad.empty() ) { glm::ivec3 pos = chunksToLoad.front();//crash worldIn->queueMutex.unlock(); Chunk* p = new Chunk( pos, worldIn ); worldIn->sendChunk( p ); worldIn->queueMutex.lock(); chunksToLoad.pop(); } worldIn->queueMutex.unlock(); }
chunksToLoad est une queue remplie au début du programme et destiné a être rempli au fur et a mesure par le thread,donc pas d’accès simultané
Code world.cpp : 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 #include "world.h" #include <vector> #include <chunk.h> #include <iostream> using namespace glm; World::World() { ChunkLoading chunkLoader(this); } World::~World() { //dtor } void World::addChunks(){ queueMutex.lock(); while(!chunksLoaded.empty()) { Chunk* p=chunksLoaded.front(); chunksLoaded.pop(); chunkMap[p->Getpos()]=p; p->init(); } queueMutex.unlock(); } std::unordered_map<ivec3,Chunk*>::const_iterator World::getChunk(ivec3 pos){ return chunkMap.find(pos); } void World::sendChunk(Chunk* p){ chunksLoaded.push(p); }
tandis que chunksLoaded est une queue de chunks préchargés rempli par le thread(via sendchunk) et consommé par la boucle principale(via addChunks),c'est donc celui là que j'ai protégé
Ligne 8, tu crées un ChunkLoading.
Dans le constructeur de ChunkLoading, tu lances un thread qui va utiliser le ChunkLoading.
Mais ligne 9, tu quittes le World::World() donc ton objet chunkLoader de type ChunkLoading disparaît immédiatement.
Quand le thread s’exécute, l'objet ChunkLoading est déjà plus là d'où un plantage quand le thread veut y accéder.
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager