Concurrency Confusion

[Chris via Digitalmars-d-learn]

On Thursday, 6 August 2015 at 21:17:15 UTC, 岩倉 澪 wrote:
> On Tuesday, 4 August 2015 at 08:35:10 UTC, Dicebot wrote:
>>     // in real app use `receiveTimeout` to do useful stuff 
>> until
>>     // result message is received
>>     auto output = receiveOnly!(immutable(Bar)[]);
>
> New question: how would I receive a immutable value with 
> receiveTimeout? I need the results from my worker thread 
> outside of the delegate that receiveTimeout takes.
>
> Also: what is the best way to kill off the worker thread when I 
> close the application, without having to wait for the worker 
> thread to complete? My first thought was to use receiveTimeout 
> in the worker thread, but the work is being done in a parallel 
> foreach loop, and I am not sure if there is a way to safely use 
> receiveTimeout in a parallel situation...
> I also found Thread.isDaemon in core.thread. I tried doing auto 
> thread = Thread.getThis(); thread.isDaemon = true; at the start 
> of the worker thread, but it still seems to wait for it to 
> complete before closing.
>
> Thanks again!

receiveTimeout can be used like this:

void main()
{
     spawn(&workerFunc);

     writeln("Waiting for a message");
     bool received = false;
     while (!received) {
         received = receiveTimeout(600.msecs,
                                   (string message) {  // <=== 
Receiving a value
                                       writeln("received: ", 
message);
                                 });

         if (!received) {
             writeln("... no message yet");

             /* ... other operations may be executed here ... */
         }
     }
}
(cf. http://ddili.org/ders/d.en/concurrency.html)

To stop threads immediately, I've found that the best way is to 
use a shared variable, typically a bool, that is changed only in 
one place. I hope I'll find the time on Monday to post a simple 
example.

1. shared bool ABORT;
2.
3.// in owner thread
4. ABORT = true;  // The only place where you do this.
5. bool res;
6. while ((res = receiveOnly!bool()) == false) { debug 
writeln("waiting for abort ..."); }



// in worker thread(s)

foreach ()
{
   if (ABORT)
     break;
   // working away
}
// ...
ownerTid.send(true);

If you have more than one thread to abort, you'll have to adapt 
lines 5 and 6 accordingly.

Unfortunately, sending an abort message to a thread as in 
`send(thread, true)` takes too long. Setting a global flag like 
ABORT is instantaneous. Beware of data races though. You might 
want to have a look at:

http://ddili.org/ders/d.en/concurrency_shared.html

Especially `synchronized` and atomicOp.