public static void main(String[] args) {
		//Mirror是個單例的，只構建了一個對象
		Mirror mirror = new Mirror("魔鏡");
		
		//三個線程都在用這面鏡子
		MirrorThread thread1 = new MirrorThread(mirror,"張三");
		MirrorThread thread2 = new MirrorThread(mirror,"李四");
		MirrorThread thread3 = new MirrorThread(mirror,"王二");
		
		thread1.start();
		thread2.start();
		thread3.start();
	}

public class MirrorThread extends Thread{
	private Mirror mirror;	
	private String threadName;	
	public MirrorThread(Mirror mirror, String threadName){
		this.mirror = mirror;
		this.threadName = threadName;
	}
		
	//照鏡子
	public String lookMirror() {
		return threadName+" looks like "+ mirror.getNowLookLike().get();
	}
	
	//化妝
	public void makeup(String makeupString) {
		mirror.getNowLookLike().set(makeupString);
	}
	
	@Override
    public void run() {
		int i = 1;//閾值
		while(i<5) {
			try {
				long nowFace = (long)(Math.random()*5000);
				sleep(nowFace);
				StringBuffer sb = new StringBuffer();
				sb.append("第"+i+"輪從");
				sb.append(lookMirror());
				makeup(String.valueOf(nowFace));
				sb.append("變?yōu)?);
				sb.append(lookMirror());
				System.out.println(sb);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			i++;
		}
	}
}

public class Mirror {
	private String mirrorName;	
	//每個人要看到自己的樣子，所以這里要用ThreadLocal
	private ThreadLocal<String> nowLookLike;	
	public Mirror(String mirrorName){
		this.mirrorName=mirrorName;
		nowLookLike = new ThreadLocal<String>();
	}
 
	public String getMirrorName() {
		return mirrorName;
	}
 
	public ThreadLocal<String> getNowLookLike() {
		return nowLookLike;
	}
}

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

public class ThreadLocalExample {
    public static class MyRunnable implements Runnable {
        private ThreadLocal<Double> threadLocal = new ThreadLocal();
        private Double variable;
 
        @Override
        public void run() {
            threadLocal.set(Math.floor(Math.random() * 100D));
            variable = Math.floor(Math.random() * 100D);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
 
            System.out.println("ThreadValue==>"+threadLocal.get());
            System.out.println("Variable==>"+variable);
        }
    }
    
    public static void main(String[] args) {
        MyRunnable sharedRunnableInstance = new MyRunnable();
        Thread thread1 = new Thread(sharedRunnableInstance);
        Thread thread2 = new Thread(sharedRunnableInstance);
        thread1.start();
        thread2.start();
    } 
}

/**
  * Returns the value in the current thread's copy of this
  * thread-local variable.  If the variable has no value for the
  * current thread, it is first initialized to the value returned
  * by an invocation of the {@link #initialValue} method.
  * 
  * 返回此線程局部變量的當前線程副本中的值。
  * 如果該變量沒有當前線程的值，則首先將其初始化為調用{@link #initialValue}方法返回的值。
  * @return the current thread's value of this thread-local
  */
public T get() { }
 
/**
  * Sets the current thread's copy of this thread-local variable
  * to the specified value.  Most subclasses will have no need to
  * override this method, relying solely on the {@link #initialValue}
  * method to set the values of thread-locals.
  *
  * 將此線程局部變量的當前線程副本設置為指定值。
  * 大多數子類將不需要重寫此方法，而僅依靠{@link #initialValue}方法來設置線程局部變量的值。
  *
  * @param value the value to be stored in the current thread's copy of
  *              this thread-local.
  *              要存儲在此本地線程的當前線程副本中的值。
  */
public void set(T value) { }
 
/**
  * Removes the current thread's value for this thread-local
  * variable.  If this thread-local variable is subsequently
  * {@linkplain #get read} by the current thread, its value will be
  * reinitialized by invoking its {@link #initialValue} method,
  * unless its value is {@linkplain #set set} by the current thread
  * in the interim.  This may result in multiple invocations of the
  * {@code initialValue} method in the current thread.
  * 刪除此線程局部變量的當前線程值。
  * 如果此線程局部變量隨后被當前線程{@linkplain #get read}調用，
  * 則其值將通過調用其{@link #initialValue}方法來重新初始化，
  * 除非當前值是在此期間被設置{@linkplain #set set}。
  * 這可能會導致在當前線程中多次調用{@code initialValue}方法。
  * @since 1.5
  */
public void remove() { }
 
/**
  * Returns the current thread's "initial value" for this
  * thread-local variable.  This method will be invoked the first
  * time a thread accesses the variable with the {@link #get}
  * method, unless the thread previously invoked the {@link #set}
  * method, in which case the {@code initialValue} method will not
  * be invoked for the thread.  Normally, this method is invoked at
  * most once per thread, but it may be invoked again in case of
  * subsequent invocations of {@link #remove} followed by {@link #get}.
  * 返回此線程局部變量的當前線程的“初始值”。
  * 除非線程先前調用了{@link #set}方法，
  * 否則線程第一次使用{@link #get}方法訪問該變量時將調用此方法，
  * 在這種情況下，{@ code initialValue}方法將不會為線程被調用。
  * 通常，每個線程最多調用一次此方法，
  * 但是在隨后調用{@link #remove}之后再調用{@link #get}的情況下，可以再次調用此方法。
  *
  * <p>This implementation simply returns {@code null}; if the
  * programmer desires thread-local variables to have an initial
  * value other than {@code null}, {@code ThreadLocal} must be
  * subclassed, and this method overridden.  Typically, an
  * anonymous inner class will be used.
  * 此實現(xiàn)僅返回{@code null};如果程序員希望線程局部變量的初始值不是{@code null}，
  * 則必須將{@code ThreadLocal}子類化，并重寫此方法。通常，將使用匿名內部類。
  *
  * @return the initial value for this thread-local
  */
protected T initialValue(){ }

 public T get() {
    //獲取當前線程
    Thread t = Thread.currentThread();
    //通過當前線程獲取ThreadLocalMap
    //Thread類中包含一個ThreadLocalMap的成員變量
    ThreadLocalMap map = getMap(t);
    //如果不為空，則通過ThreadLocalMap中獲取對應value值
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //如果為空，需要初始化值
    return setInitialValue();
}
private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        //如果為空，則創(chuàng)建
        createMap(t, value);
    return value;
｝

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

protected T initialValue() {
    return null;
}

static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
    private final Supplier<? extends T> supplier; 
    SuppliedThreadLocal(Supplier<? extends T> supplier) {
        this.supplier = Objects.requireNonNull(supplier);
    }
    
    @Override
    protected T initialValue() {
        return supplier.get();
    }
}

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object val
    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}
 
public WeakReference(T referent) {
    super(referent); //referent：ThreadLocal的引用
}
 
//Reference構造方法     
Reference(T referent) {
    this(referent, null);//referent：ThreadLocal的引用
}
 
Reference(T referent, ReferenceQueue<? super T> queue) {
    this.referent = referent;
    this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}