ThreadLocal：为什么一个线程所做的更改在另一个线程中可见

Question

Consider following code:

public static void main(String args[]) {
        
        
        Set<Integer> set=new HashSet<>();
       set.add(1);
        
        ThreadLocal<Set> var1=new ThreadLocal<>();
        
        //THREAD1
        Runnable r=()->{
                    
            var1.set(set);

            for(int i=1;i<=10;i++)
             System.out.println("Thread ID:"+Thread.currentThread()+":  "+var1.get());
            };

        Thread th=new Thread(r);
        th.start();
        
        //THREAD2
        Thread th1=new Thread(()-> {
                
            var1.set(set);
            
            var1.get().remove(1); //removing 1 from this thread copy of set.
            var1.get().add(2);    //adding 2 to this thread copy of set 
            
            for(int i=1;i<=10;i++)
             System.out.println("Thread ID:"+Thread.currentThread()+":  "+var1.get());
             
        });
        th1.start();
        
        
    }

Output:

Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-0,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]
Thread ID:Thread[Thread-1,5,main]:  [2]

Why changes made by Thread2(ie removing of 1 and addition of 2) is visible to thread1 also? What will be the ideal use case here?

Answer 1

A thread local is not a copy of the value (what you are storing), it's more like a copy of the variable (the place you are storing it). It's a variable that stores (generally) a different value for each thread that accesses it.

While the ThreadLocal is capable of referencing different values in each thread, you have assigned the same value to both. Mutations of the value in one thread happen to be visible in the other. (This is not guaranteed, however; this concurrent access to a HashSet is likely to result in bugs.)

A more useful application of ThreadLocal would assign distinct values for each thread. In your example, this means creating a HashSet inside the Runnable . This maintains the isolation of each value to one thread, and avoids the concurrency bugs you have in your code.

I am not sure there is an "ideal" use case for ThreadLocal ; I see it as a tool for workarounds when the ideal is not possible. I see them as a necessary evil, a last resort. But, for example, you could use a ThreadLocal to pass extra data up and down the stack when it can't be passed as method parameters.