Is there a data visibility issue here?

Question

class Sample
{
  int a = 0;
  public void Run()
  {
     // main thread.Assuming this is chromium task runner.
     auto currentRunner = GetCurrentDefault();
     somePooledRunner->PostTask(
     [currentRunner, this]()
     {
        a = TimeConsumingOperation();
        // post back to main thread.
        currentRunner->PostTask([this]()
        {
            OnComplete1(a);
            OnComplete2();
        });
     });
  }
  
  void OnComplete1(int aParameter)
  {
      Process(aParameter);
  }
  
  void OnComplete2()
  {
     Process(this->a); // Is there a data visibility issue here that I'm overlooking but is being handled correctly by the library I'm using?
  }
}

This is similar to SynchronizationContext.Post for async/await. The lockfree or lock-based implementation of task queues helps me handle these issues correctly. But when I put aside these and face this problem, I wonder if there is really a problem here.

class SimpleSample
{
    int a = 0;
    void Run()
    {
        auto t = std::thread([this]()
            {
                a = TimeConsumingOperation();
            });

        t.detach();
        // To simplify the problem, no synchronization mechanism is introduced, and only sleep is performed. 
        Sleep(enoughTime);
        // Assume that the sleep time is sufficient for TimeConsumingOperation to complete and write a in worker thread. Is there a possibility that I cannot obtain the calculation result of a due to data visibility?

        // printf(a);
        Process(a);
    }
}

Is there a possibility that I cannot obtain the calculation result of a due to data visibility, in SimpleSample?

A note: Thanks guys, but please don't offer suggestions on how to use asynchronous APIs; that's beside the point. I'm just trying to figure out if there's a data visibility issue here, so I'm not introducing any synchronization mechanisms or extra function calls.

Added the c++ tag because the base language tag should always be present. — wohlstad
– wohlstad, Commented Aug 22 at 4:39
Yes you have a problem : Detaching a thread is almost never a good idea. And so is adding "Sleep" to preventing race conditions. Never write that kind of code again. Learn about : thread.join, or std::jthread. Next steps std::condition_variable/std::mutex and lastly lock-free programming (hard) — Pepijn Kramer
– Pepijn Kramer, Commented Aug 22 at 4:45
There's likely enough synchronization baked into Sleep call - it usually trips into kernel mode and back, and that involves fences galore. — Igor Tandetnik
– Igor Tandetnik, Commented Aug 22 at 4:48
@IgorTandetnik and at the same time it is totally unmaintainable in the long run, so I would run away from solutions like this ;) — Pepijn Kramer
– Pepijn Kramer, Commented Aug 22 at 4:51
Also in your example you will never know when a finally has the correct calculated value so in that respect it will not work either. Some side notes : don't use printf, use std::print, the documentation for std::async. — Pepijn Kramer
– Pepijn Kramer, Commented Aug 22 at 5:40

Pepijn Kramer · Accepted Answer · 2025-08-22 04:50:07Z

0

When you want to calculate something on a background thread use std::future/std::async

#include <future>

int main()
{
    std::future<int> future = std::async(std::launch::async, []()
    { 
        return TimeConsumingOperation(); 
    };

        // do other things here
    
    int a = future.get();
    return a;
}

answered Aug 22 at 4:50

Pepijn Kramer

14k4 gold badges12 silver badges27 bronze badges

Sign up to request clarification or add additional context in comments.

Collectives™ on Stack Overflow

Is there a data visibility issue here?

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related