Discussion :

[Invité]

Bonjour à tous,

J'aurais besoin de l'avis d'experts, car je ne suis pas certain d'avoir bien compris ce que j'ai lu.

Mon application doit, entre nombreuses autres choses, communiquer en série avec un périphérique externe.

J'utilise donc un objet QSerialPort. Il est créé et encapsulé par une instance d'une classe à moi : SerialProtocol (chargée d'ajouter et d'interpréter des headers aux messages, entre autres). Cet objet SerialProtocol comporte son propre thread, utilisé par move :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
thread = new QThread;
this->moveToThread(thread);
thread->start();

Un timer également porté par SerialProtocol déclenche la lecture du port série toutes les 50 ms.

Chaque entité de l'application est obligée de passer par ce SerialProtocol pour utiliser le port série. Seulement plusieurs entités de l'application peuvent avoir besoin d'accéder au même port série, et généralement depuis des threads différents. Pour ce faire, chaque entité accède au port série via une instance de SerialInterfaceAccessor. Ce SerialInterfaceAccessor porte un membre QSharedPointer<SerialProtocol> qui est un pointeur partagé vers l'objet SerialProtocol.

On a donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
SerialInterfaceAccessor::QSharedPointer<SerialProtocol> -----------|
                                                                   V
SerialInterfaceAccessor::QSharedPointer<SerialProtocol>  --------> SerialProtocol::QSharedPointer<QSerialPort>  ------->  QSerialPort
                                                                   ^
SerialInterfaceAccessor::QSharedPointer<SerialProtocol>  ----------|

Ma question concerne précisément QSharedPointer, donc la doc précise :

Thread-Safety
QSharedPointer and QWeakPointer are thread-safe and operate atomically on the pointer value. Different threads can also access the QSharedPointer or QWeakPointer pointing to the same object at the same time without need for locking mechanisms.
It should be noted that, while the pointer value can be accessed in this manner, QSharedPointer and QWeakPointer provide no guarantee about the object being pointed to. Thread-safety and reentrancy rules for that object still apply.

Ai-je bien compris, cela signifie-t-il que mon application peut fonctionner ainsi sans que j'ai à me soucier de placer des mutex au niveau de SerialProtocol ?

[Amnell]

Bonjour,

De mon point de vue, cela veut dire qu'avoir un même QSharedPointer auquel on accède en même temps sur différents threads ne nécessite pas de mutex (on parle ici de l'instance de QSharedPointer, pas de la ressource gardée par le QSharedPointer). Par exemple, si deux threads font un if (ptr.isNull()) en même temps, il n'y a pas besoin de mutexer. Cependant, ce qui est indiqué, c'est qu'il n'y a aucune garantie sur l'objet pointé. Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
// Thread 1 :
 
if (!ptr.isNull())
{
    ptr->doSomething();
}
 
// Thread 2 :
 
if (!ptr.isNull())
{
    ptr.clear();
}

Au moment du !isNull(), on recevra peut-être true, d'un côté et/ou de l'autre, sauf que si le thread 2 opère plus rapidement, à ce moment il aura libéré le pointeur et ptr->doSomething() donnera un crash vu que l'instance gardée ne sera plus valide. Il faut donc bien mutexer, de mon point de vue.

Bonne journée,
Louis