CODEWITHSUNDEEP
c++multithreading
eet
eet

Reputation: 135

C++ Async Threads

I'm very confused with std::thread and std::async. Here is my code:

#include <vector>
#include <thread>
#include <mutex>

std::vector<int> myvector = {};
std::mutex mu;
int result;

void samplefunc(int a, int& result){
    result = 2 * a;
}

void func1(){
    while(true){
        std::unique_lock locker(mu);
        locker.lock();
        std::vector<int> temp = myvector;
        locker.unlock();
        if(myvector.size() > 0){
            samplefunc(myvector.at(0),result);
            myvector.clear();
        }else{
            samplefunc(0,result);
        }
    }
}

void func2(){
    while(true){
        //do complex things, suppose after complex calculations we have result dummy which is type int
        int dummy = 0;
        std::unique_lock locker(mu);
        locker.lock();
        myvector.push_back(dummy);
        locker.unlock();
    }
}

int main(){
    std::thread t1(func1);
    std::thread t2(func2);
    t1.join();
    t2.join();
}

What I want to do is very simple. We have two threads which should run in parallel (i.e. they don't have to wait on each other). However, thread t1 is supposed to change its behaviour if thread t2 puts some integer in a shared vector. Does the code given above achieve this, or should we use std::async, std::future, etc?

Upvotes: 2

Views: 107

Answers (1)

WilliamClements
WilliamClements

Reputation: 350

If the shared data is properly synchronized, it is fine for modification from one thread on the shared data to affect computation using that data in separate thread. But you haven't locked myvector sufficiently. The lock has to surround all reading steps on the shared data. In func1, you release the lock too soon.

Upvotes: 2

Related Questions