Concurrency bug (and solution)

main.cpp

#include <iostream>
#include <vector>
#include <memory>
#include <thread>

class Base
{
public:
    
    /**
     * Public interface to a complex algorithm.
     *
     * The complex algorithm can have variants (e.g., 
     * put the data in the correct shape, apply some 
     * post-processing to remove outliers in the result...).
     * The virtual methdos are private so that clients of the class
     * do only see a stable interface and the sequence of execution
     * does also remain stable.
     *
     * The outline of the algorithm is always:
     * 1. pre-processing step (can be overriden)
     * 2. processing (fixed)
     * 3. result post-processing (can be overriden)
     */
    void performComplexAlgorithm() const
    {
	preprocessing();
	processing();
	postprocessing();
    }

private:

    /**
     * Prepare the data (e.g., convert RGB images to GRAY).
     * Can be overriden by subclasses.
     */
    virtual void preprocessing() const
    {
	std::cout << "Base::" << __FUNCTION__ << std::endl;
    }

    /**
     * Really solve the problem here.
     */
    void processing() const
    {
	std::cout << "Base::" << __FUNCTION__ << std::endl;
    }

    /**
     * Post-process the data (remove outliers, put back to RGB...).
     * Can be overriden by subclasses.
     */
    virtual void postprocessing() const
    {
	std::cout << "Base::" << __FUNCTION__ << std::endl;
    }
};

/**
 * Specialized class to deal with a certain type of data
 */
class Derived : public Base
{
private:

    /**
     * This special type of data needs to be put into a usable shape 
     * for our brilliant processing function.
     */
    virtual void preprocessing() const override
    {
	std::cout << "Derived::" << __FUNCTION__ << std::endl;	
    }

};

void wrongWorker(Base const solver)
{
    std::cout << "Inside " <<  __FUNCTION__ << std::endl;
    solver.performComplexAlgorithm();
}

void correctWorker(Base const& solver)
{
    std::cout << "Inside " <<  __FUNCTION__ << std::endl;
    solver.performComplexAlgorithm();
}

int main()
{
    std::cout << "Sanity check: call performComplexAlgorithm from Derived:" << std::endl;
    Derived D0;
    D0.performComplexAlgorithm();

    std::cout << std::endl;

    std::unique_ptr<Base> D1 = std::unique_ptr<Derived>(new Derived);
    std::cout << "Polymorphic access via a pointer:" << std::endl;
    D1->performComplexAlgorithm();

    std::cout << std::endl;

    std::cout << "Wrong (calls methods from the BASE class):" << std::endl;
    wrongWorker(*D1);

    std::cout << std::endl;

    std::cout << "Correct (calls methods from the DERIVED class):" << std::endl;
    correctWorker(*D1);
}