详谈ThreadLocal-单例模式下高并发线程安全

目录

• ThreadLocal-单例模式下高并发线程安全

• 为了解决线程安全的问题，我们有3个思路：

• 1.ThreadLocal概述
• 2. ThreadLocal简单实用
• 3.ThreadLocal的内部原理

• 3.1 get方法
• 3.2 set方法
• 3.3 remove方法
• 3.4 initialValue方法

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("变为");
				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.
  * 此实现仅返回{@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
        //如果为空，则创建
        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;
}