How come a thread can access another thread's stack variable?

[Simen Kjærås]

On Tue, 22 Nov 2011 23:00:17 +0100, Andrej Mitrovic  
<andrej.mitrovich at gmail.com> wrote:

> import core.thread;
> import std.stdio;
>
> struct Foo
> {
>     int field;
>     void test()
>     {
>         writeln("field: ", &field);
>     }
> }
>
> void main()
> {
>     Foo foo;
>     auto thread = new Thread(&foo.test);
>     thread.start();
>     thread.join();
>     foo.test();
> }
>
> This prints the same addresses. std.concurrency won't let you do this,
> while std.parallelism uses some form of "weaker isolation", and it
> seems core.thread has the same weaker isolation principle.
>
> If "foo" is in TLS, how come a new thread can access its members?

You are passing a delegate that contains the pointer to the Foo you
have put on the stack. What would you expect to happen?

foo is not in tls, it is on the stack (which is also thread-local, but
not considered tls). Passing an object on the stack to another thread
is almost never safe, as the stack may unwind before the thread is
done with the object.

If you want to do this with tls, make a static/global variable with a
Foo, and operate on it directly instead of passing the object between
threads:

import core.thread;
import std.stdio;

struct Foo {
     int field;
}

Foo foo;

void test()
{
     writeln("field: ", &foo.field);
}

void main()
{
     auto thread = new Thread(&test);
     thread.start();
     thread.join();
     test();
}