The standard allows for this behavior, although it doesn’t guarantee it. From 3.7.2/2 [basic.stc.thread]: A variable with thread storage duration shall be initialized before its first odr-use (3.2) and, if constructed, shall be destroyed on thread exit. It’s also possible that the objects are constructed at some other time (e.g. on program startup), as “before … Read more
I had a look at the code in ThreadLocal<T> to see what the current Dispose is doing and it appears to be a lot of voodoo. Obviously disposing of thread-related stuff. But it doesn’t dispose of the values if T itself is disposable. Now, I have a solution – a ThreadLocalDisposables<T> class, but before I … Read more
In C and C++, thread-local storage applies to static variables or to variables with external linkage only. Local (automatic) variables are usually created on the stack and therefore are specific to the thread that executes the code, but global and static variables are shared among all threads since they reside in the data or BSS … Read more
If we consider the traditional Java approach the answer can be deducted from the quote bellow as being much slower: Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code … Read more
You just override the initialValue() method: private static ThreadLocal<List<String>> myThreadLocal = new ThreadLocal<List<String>>() { @Override public List<String> initialValue() { return new ArrayList<String>(); } };
The set of ThreadLocal instances associated with a thread are held in private members of each Thread. Your only chance to enumerate these is to do some reflection on the Thread; this way, you can override the access restrictions on the thread’s fields. Once you can get the set of ThreadLocal, you could copy in … Read more
A thread is a unit of execution and so multiple thread can execute the same code at the same time. If multiple threads execute on an object/instance at the same time they will share the instance variables. Each thread will have its own local variables but it is difficult to share these across objects without … Read more
Something the blog post noted in the comments doesn’t make explicit, but I find to be very important, is that [ThreadStatic] doesn’t automatically initialize things for every thread. For example, say you have this: [ThreadStatic] private static int Foo = 42; The first thread that uses this will see Foo initialized to 42. But subsequent … Read more
DynamicVariable is an implementation of the loan and dynamic scope patterns. Use-case of DynamicVariable is pretty much similar to ThreadLocal in Java (as a matter of fact, DynamicVariable uses InheritableThreadLocal behind the scenes) – it’s used, when you need to do a computation within an enclosed scope, where every thread has it’s own copy of … Read more
Sigh, this is old news Well, a bit late to the party on this one. In October 2007, Josh Bloch (co-author of java.lang.ThreadLocal along with Doug Lea) wrote: “The use of thread pools demands extreme care. Sloppy use of thread pools in combination with sloppy use of thread locals can cause unintended object retention, as … Read more