synchronization

If you heap allocate an object with shared_ptr on thread A , then copy the shared_ptr to another thread without any synchronization. Is the other thread guaranteed to see a fully constructed object? int main(){ auto sp = std::make_shared<int>(5); auto f=std::async(std::launch::async, [sp](){ std::cout<<*sp;}); } Is it guaranteed to print 5? In your example, the shared_ptr object has been duplicated before std::async returns, hence it still exists in the new thread even if the original shared_ptr is destroyed before the second thread accesses it's copy. So, the answer is yes. You are passing by

I have a program with one main thread where I spawn a second thread that uses asyncio. Are there any tools provided to synchronize these two threads? If everything was asyncio, I could do it with its synchronization primitives, eg: import asyncio async def taskA(lst, evt): print(f'Appending 1') lst.append(1) evt.set() async def taskB(lst, evt): await evt.wait() print('Retrieved:', lst.pop()) lst = [] evt = asyncio.Event() asyncio.get_event_loop().run_until_complete(asyncio.gather( taskA(lst, evt), taskB(lst, evt), )) However, this does not work with multiple threads. If I just use a threading

I know that hundreds of variations of these considerations have been posted all over the net. However, I haven't found anything that adresses my exact problem, so I hope you can help me see the light. I'm currently toying with 2D game development in Java using OpenGL. The language and graphics library used is not that relevant to my question though as it has a more general character. I'm attempting to design a general purpose game loop which can be used more or less as is for any game that has moderately heavy graphics (mostly bitmap textures) and possibly even heavier game logic (AI,