Combining Unique type with concurrency module

[Ali Çehreli via Digitalmars-d-learn]

On 09/14/2015 12:07 AM, Alex wrote:

 > Do you have a hint how to create such a type? The needed operation is
 > "onPassingTo" another thread. So the idea is to create a resource, which
 > is not really shared (a question of definition, I think), as it should
 > be accessible only from one thread at a time.
 > But there is a "main" thread, from which the resource can be lent to
 > "worker" threads and there are "worker" threads, where only one worker
 > can have the resource at a given time.

Here is an unpolished solution that enforces that the thread that is 
using it is really its owner:

struct MultiThreadedUnique(T) {
     Tid currentOwner;
     Unique!T u;

     this(Unique!T u) {
         this.u = u.release();
         this.currentOwner = thisTid;
     }

     void enforceRightOwner() {
         import std.exception;
         import std.string;
         enforce(currentOwner == thisTid, format("%s is the owner; not %s",
                                                 currentOwner, thisTid));
     }

     ref Unique!T get() {
         enforceRightOwner();
         return u;
     }

     void giveTo(Tid newOwner) {
         enforceRightOwner();
         currentOwner = newOwner;
     }
}

The entire program that I tested it with:

import std.stdio;
import std.concurrency;
import std.typecons;

void spawnedFunc2(Tid ownerTid)
{
     receive(
         (shared(MultiThreadedUnique!S) * urShared)
         {
             auto ur = cast(MultiThreadedUnique!S*)urShared;
             writeln("Recieved the number ", ur.get().i);
             ur.giveTo(ownerTid);
         }
     );
     send(ownerTid, true);
}

static struct S
{
     int i;
     this(int i){this.i = i;}
}

Unique!S produce()
{
     // Construct a unique instance of S on the heap
     Unique!S ut = new S(5);
     // Implicit transfer of ownership
     return ut;
}

struct MultiThreadedUnique(T) {
     Tid currentOwner;
     Unique!T u;

     this(Unique!T u) {
         this.u = u.release();
         this.currentOwner = thisTid;
     }

     void enforceRightOwner() {
         import std.exception;
         import std.string;
         enforce(currentOwner == thisTid, format("%s is the owner; not %s",
                                                 currentOwner, thisTid));
     }

     ref Unique!T get() {
         enforceRightOwner();
         return u;
     }

     void giveTo(Tid newOwner) {
         enforceRightOwner();
         currentOwner = newOwner;
     }
}

void main()
{
     MultiThreadedUnique!S u1 = produce();
     auto childTid2 = spawn(&spawnedFunc2, thisTid);

     u1.giveTo(childTid2);
     send(childTid2, cast(shared(MultiThreadedUnique!S*))&u1);

     import core.thread;
     thread_joinAll();

     writeln("Successfully printed number.");
     auto u2 = &u1.get();
}

Ali