getTid wrapper

[Stanislav Blinov]

On Tuesday, 4 March 2014 at 15:52:37 UTC, Timothee Cour wrote:

> quoting from there:
> "The type of thisTid is Tid, but its value has no significance 
> for the
> program. Further, both threads report it to be surprisingly at 
> the same
> address:
> Owner : Tid(std.concurrency.MessageBox), address: 809C360
> Worker: Tid(std.concurrency.MessageBox), address: 809C360"

That part talks about thisTid, not Thread.getThis. Perhaps that 
book section is indeed not clear enough. &thisTid actually gets 
an address of 'thisTid', which is (at least in current 
implementation) a function.

> Likewise with writeln(&Thread.getThis);

Same as above. So you're printing function pointers, which are of 
course the same for every thread.

> How would I print a number/string that uniquely identifies a 
> thread?
> Tid is an opaque type, writeln(thisTid) isn't of any use.

If you want to print it, you can do so like this:

writefln("%s", cast(void*)Thread.getThis);

That is, you cast a reference returned by Thread.getThis() to a 
void* (a reference is a glorified pointer, after all). If you 
want to print something more meaningful, you can utilize the 
'name' property of Thread.

For simple identification purposes (i.e. when you want to check 
if the calling thread is the one you need), both thisTid and 
Thread.getThis can be used:

if (thisTid == expectedTid) { ... }

if (Thread.getThis is expectedThread) { ... }

If you don't feel like printing addresses or using name(), you 
can even build your own id system, i.e. like this:

-->8--

module threadid;

import core.atomic;

private shared uint lastID; // shared
private uint thisID;        // TLS

static this() { thisID = atomicOp!"+="(lastID, 1); }

@property uint threadID() { return thisID; }

--8<--

...or something to that extent. Now every thread that you ever 
create will get an ID number (from 0 to uint.max, be careful 
though if your app creates more than uint.max threads :o) ), 
which can be queried at any time:

import threadid;

//...

writeln(threadID);