Sharing a variable of type std::vector between QThread classes

[ahawkthomas]

Hello! I have a C++ library based on Qt 5 that uses multiple threads (classes inherited from QThread) for some computations. I need to share a STL vector between them (threads don't perform any pushing/popping with this vector, but they change it's values). I use the special wrapper around std::atomic:

struct AtomicUInt64
{
    std::atomic<uint64_t> atomic;
 
    AtomicUInt64() : atomic ( uint64_t() ) {}
 
    explicit AtomicUInt64 ( uint64_t const &v ) : atomic ( v ) {}
    explicit AtomicUInt64 ( std::atomic<uint64_t> const &a ) : atomic ( a.load() ) {}
 
    AtomicUInt64 ( AtomicUInt64 const &other ) : atomic ( other.atomic.load() ) {}
 
    AtomicUInt64 &operator= ( AtomicUInt64 const &other )
    {
        atomic.store ( other.atomic.load() );
        return *this;
    }
 
    AtomicUInt64 operator++ ()
    {
        this->atomic++;
        return *this;
    }
};

struct AtomicUInt64
{
    std::atomic<uint64_t> atomic;

    AtomicUInt64() : atomic ( uint64_t() ) {}

    explicit AtomicUInt64 ( uint64_t const &v ) : atomic ( v ) {}
    explicit AtomicUInt64 ( std::atomic<uint64_t> const &a ) : atomic ( a.load() ) {}

    AtomicUInt64 ( AtomicUInt64 const &other ) : atomic ( other.atomic.load() ) {}

    AtomicUInt64 &operator= ( AtomicUInt64 const &other )
    {
        atomic.store ( other.atomic.load() );
        return *this;
    }

    AtomicUInt64 operator++ ()
    {
        this->atomic++;
        return *this;
    }
};

To copy to clipboard, switch view to plain text mode 

And std::vector in a data structure:

struct ThreadInput
{
    std::vector<AtomicUInt64> *atomsUsed = NULL;
    //other variables
};

struct ThreadInput
{
    std::vector<AtomicUInt64> *atomsUsed = NULL;
    //other variables
};

To copy to clipboard, switch view to plain text mode 

I initialize this structure in a class that manages threads:

CalculationThread threadData;
threadData.myVect = new std::vector<AtomicUInt64>();
for ( int x = 0; x < 100; ++x )
{
    AtomicUInt64 value ( 0 );
    threadData.myVect->push_back ( value );
}
//assign other variables in 'threadData'
for ( int x = 0; x < 2; ++x )
{
    MyThread *thread = new MyThread ( threadData );
    thread->start();
}

CalculationThread threadData;
threadData.myVect = new std::vector<AtomicUInt64>();
for ( int x = 0; x < 100; ++x )
{
    AtomicUInt64 value ( 0 );
    threadData.myVect->push_back ( value );
}
//assign other variables in 'threadData'
for ( int x = 0; x < 2; ++x )
{
    MyThread *thread = new MyThread ( threadData );
    thread->start();
}

To copy to clipboard, switch view to plain text mode 

Finally, this is MyThread's 'void run()' impementation:

void MyThread::run()
{
    uint64_t ull;
    for ( ull = 0; ull < this->threadData.iterations; ++ull)
    {
        //increment the 100th value of 'myVect'
        ++this->threadInput.myVect->data()[99];
    }
    qDebug() << "Finished = " + QString::number(this->thredData.myVect->data()[99].atomic) + " | it = " + QString::number(ull);
}

void MyThread::run()
{
    uint64_t ull;
    for ( ull = 0; ull < this->threadData.iterations; ++ull)
    {
        //increment the 100th value of 'myVect'
        ++this->threadInput.myVect->data()[99];
    }
    qDebug() << "Finished = " + QString::number(this->thredData.myVect->data()[99].atomic) + " | it = " + QString::number(ull);
}

To copy to clipboard, switch view to plain text mode 

So, when I set 'threadData.iterations' variable to ~490000 (this value is different for different threads), I get the following in Application Output:

"Finished = 491760 | it = 249654"
"Finished = 499308 | it = 499308"

And this is not what I expected to see. Why the first finished thread outputs that the 100th value of vector is 249654? Shouldn't it be more than iteration count, as there were 2 threads?
Maybe there are another ways to share a STL vector between instances of `MyThread` class inherited from QThread and assume that it is atomic?

[pkj]

Maybe there are another ways to share a STL vector between instances of `MyThread` class inherited from QThread and assume that it is atomic?

No there is no special way to share a std::vector or any c++ class for that matter.

And this is not what I expected to see. Why the first finished thread outputs that the 100th value of vector is 249654? Shouldn't it be more than iteration count, as there were 2 threads?

if your data, myVect is shared between the 2 threads you have created, I don't know why the result is alarming? Or is myVect/thread. How is it sharing then. Your datastructures are not clear, at least, to me.
Moreover, it is generally not required to sub-class QThread. QThread derived class stays in the thread you have created. Objects created in the run() have their affinity to the new thread. Since this is a tricky point missed by most, this is what the documentation has to say about subclassing QThread...http://doc.qt.io/qt-4.8/qthread.html#subclassing-qthread

[ahawkthomas]

Or is myVect/thread. How is it sharing then. Your datastructures are not clear, at least, to me.

Sorry if I was not clear. I send the same pointer to std::vector object to threads. So they should use the same object in memory - and this object is std::vector. Threads increment the same value in this vector by one in the loop. When the loop ends on the last running thread, I expect to see in Application Output the value equals to (loop iterations * threads count), but I see another numbers.