On some very rare cases the continuation could be executed twice in a multithreaded scenario. Consider the following example: auto f = QtConcurrent::run(someFunction); f.then(someOtherFunction); Assuming that QtConcurrent::run() is executed on Thread B, and the continuation is attached in Thread A, the following call stack is possible: 1. Thread B: someFunction() is finished 2. Thread B: QFutureInterface::reportFinished() is called 3. Thread B: QFutureInterfaceBase::reportFinished() is called and finished. 4. Thread A: then() is called. It checks that the future is already finished, so the attached continuation is executed immediately. 5. Thread B: QFutureInterfaceBase::runContinuation() is executed. At this point it sees that a continuation exists, and executes it again. Step 5 will lead to a crash, because we'll try to access a moved-from QPromise. To fix the issue, introduce a flag that is explicitly used to test if the continuation was already executed or not. The pre-existing code already uses a concept of a continuation state, but it cannot be easily extended without convering it from an enum to flags, because the canceled continuation should still be called in order to actually execute the onCanceled() handler. Wrapping QFIBP::ContinuationState into QFlags would increase its size from 1 to 4 bytes, and manually treating the enum as flags will result in a more complicated code. So, I simply picked the approach of adding an explicit flag for this case. Writing a unit-test is not really possible, but I verified that the reproducer from the linked Jira ticket does not crash anymore. Amends dfaca09e85a49d2983bb89893bfbe1ba4c19eab4 that introduced the continuations, so picking to all active Qt 6 branches. Fixes: QTBUG-118032 Pick-to: 6.9 6.8 6.5 Change-Id: I3e07722495e38367e8e4be2eded34140e22b0053 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>