Can you use two stage locking here? The strategy is called quite a lot during the merge process, so locking all the time can affect the performance. Will it be enough to move the lock into the if-block? Theoretically, it should be safe, because the strategy can never become null.

I don't think it's safe inside the if. (1) QScopedPointer::reset might set the pointer to 0 for a very short time while transitioning, depending on implementation details. (2) There is no memory sync barrier we can rely on, so the wrappedStrategy.data() we read in one thread might have already been deleted by another thread. The more I think about it, the whole QScopedPointer is actually a problem here. How can we guarantee that the wrappedStrategy that is deleted by one thread is no longer used by any other thread?

Good point! I didn't notice we delete the strategy when the wrap rect is changed. Can we do something like that?

if (!wrappedStrategy || wrappedStrategy->wrapRect() != wrapRect) {
    QMutexLocker locker(&m_wrappedStrategyMutex);

    if (!wrappedStrategy ) {
        wrappedStrategy.reset(new KisPaintDeviceWrappedStrategy(wrapRect, q, this));
    }  else if (wrappedStrategy->wrapRect() != wrapRect) {
        wrappedStrategy->setWrapRect(wrapRect); // to be implemented
    }
}

In this case KisPaintDevice never deletes the wrapped strategy. Therefore, unless a partial write happens (can it?) the first unguarded read from the scoped pointer will always be valid.

If you think the partial write can be a real problem here, it might also be safe to change the scoped pointer into QAtomicPointer and do the initialization in a lockfree manner. But there will still be a problem with calling setWrappedRect().