Access thread-local from another thread

If you want thread local variables that are not thread local, why don't you use global variables instead?

Important clarification!

I am not suggesting that you use a single global to replace a thread-local variable. I 'm suggesting of using a single global array or other suitable collection of values to replace one thread-local variable.

You will have to provide synchronization of course, but since you want to expose a value modified in thread A to thread B there's no getting around that.

Update:

The GCC documentation on __thread says:

When the address-of operator is applied to a thread-local variable, it is evaluated at run-time and returns the address of the current thread's instance of that variable. An address so obtained may be used by any thread. When a thread terminates, any pointers to thread-local variables in that thread become invalid.

Therefore, if you insist on going this way I imagine it's possible to get the address of a thread local variable from the thread it belongs to, just after the thread is spawned. You could then store a pointer to that memory location to a map (thread id => pointer), and let other threads access the variable this way. This assumes that you own the code for the spawned thread.

If you are really adventurous, you could try digging up information on ___tls_get_addr (start from this PDF which is linked to by the aforementioned GCC docs). But this approach is so highly compiler and platform specific and so lacking in documentation that it should be causing alarms to go off in anyone's head.

I am searching for the same thing. As I see nobody has answered your question after having searched the web in all ways I arrived to the subsequent information: supposing to compile for gcc on linux (ubuntu) and using -m64, the segment register gs holds the value 0. The hidden part of the segment (holding the linear address) points to the thread specific local area.That area contains at that address the address of that address ( 64 bits ). At lower addresses are stored all thread local variables.That address is the native_handle().So in order to access a threads local data you should do it via that pointer.

In other words: (char*)&variable-(char*)myThread.native_handle()+(char*)theOtherThread.native_handle()

The code that demonstrates the above supposing g++,linux,pthreads is:

#include <iostream>#include <thread>#include <sstream>thread_local int B=0x11111111,A=0x22222222;bool shouldContinue=false;void code(){    while(!shouldContinue);    std::stringstream ss;    ss<<" A:"<<A<<" B:"<<B<<std::endl;    std::cout<<ss.str();}//#define ot(th,variable) //(*( (char*)&variable-(char*)(pthread_self())+(char*)(th.native_handle()) ))int& ot(std::thread& th,int& v){    auto p=pthread_self();    intptr_t d=(intptr_t)&v-(intptr_t)p;    return *(int*)((char*)th.native_handle()+d);}int main(int argc, char **argv){               std::thread th1(code),th2(code),th3(code),th4(code);        ot(th1,A)=100;ot(th1,B)=110;        ot(th2,A)=200;ot(th2,B)=210;        ot(th3,A)=300;ot(th3,B)=310;        ot(th4,A)=400;ot(th4,B)=410;        shouldContinue=true;        th1.join();        th2.join();        th3.join();        th4.join();    return 0;}

I was unfortunately never able to find a way to do this.

Without some kind of thread init hook there just doesn't appear to be a way to get at that pointer (short of ASM hacks that would be platform dependent).