Why does multi-threaded drawing work?

[sw]

Hello,

in the SFML tutorial "Drawing 2D stuff" is at the end a section "Drawing from threads", which explains that you can handle all drawing in a seperate thread.
I don't understand why this is working:
I draw for example a sf::Sprite in the rendering thread

Code: [Select]

window.draw(sprite);
which calls sf::RenderTarget::draw and then sf::Sprite::draw. In this draw function I'm accessing the sprites data members m_origin, m_position, m_rotation and so on through the call to sf::Transformable::getTransform().
At the same time i can access this data members from the "main game loop" in another thread through calls like sf::Transformable::setPosition(), sf::Transformable::setRotation() and so on.
Aren't I'm accessing the data members then from different threads at the same time? I have nowhere seen a mutex or so, why does this work?

[Hapax]

There's a difference between "work" and "seems to work on this occasion".

The problem with accessing the same variables from different threads is not that they can't access them but they can't access them reliably. For (one simple) example, if one thread is reading a string and half-way through that read, another thread changed that string, what would happen?

"Thread Safety"

[sw]

Thank you for your answer.
I already know this about thread safety, i think maybe my first post was misleading. Maybe this question is better:

In the SFML tutorial it looks like it is ok to have no mutex or so. Therefore we would risking that two threads access the same data at the same time. Is this correct? If so, why should we do this, wouldn't it be possible that we will see not "the right things" on the screen the most time when this program is running?
Or is the programmer supposed to add mutexes / locks to prevent this?

[Hapax]

If you are accessing the same data in the main thread and the rendering thread, you will need to secure that access using a lock/mutex system.

The only thing in the example that is accessed by both threads at the same time is the window. I can't say for sure if the window is automatically thread-safe. I guess we should assume so with it being used that way in this example; if it isn't, this example should be changed.

[sw]

Ok, thanks  .