ThreadLocal知识点

package com.newwork.tandashi;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * 
 * @author tandashi
 * SimpleDateFormat 多线程下有线程安全问题
 *
 */
public class MyThread extends Thread{
	private SimpleDateFormat sdf;
	private String dateString;
	public MyThread(SimpleDateFormat sdf,String dateString){
		this.sdf = sdf;
		this.dateString = dateString;
	}
	
	@Override
	public void run() {
		
		try {
			Date newDate =  sdf.parse(dateString);
			String newDateString = sdf.format(newDate);
			if(!newDateString.equals(dateString)){
				System.out.println(this.getName()+"的日期："+dateString +"转化日期后出错："+newDateString);
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
	
}

package com.newwork.tandashi;

import java.text.SimpleDateFormat;
/**
 * 
 * @author tandashi
 * SimpleDateFormat 多线程下有线程安全问题，测试类 
 * 转换出错
 *
 */
public class ThredTest {
	public static void main(String[] args) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String[] dateString = new String[]{"2000-01-01","2000-01-02","2000-01-03","2010-10-01"};
		MyThread[] threads = new MyThread[4];
		
		for (int i = 0; i < threads.length; i++) {
			threads[i]  = new MyThread(sdf,dateString[i]);
		}
		for (int i = 0; i < threads.length; i++) {
			threads[i].start();
		}
	}
	

}

Thread-3的日期：2010-10-01转化日期后出错：1999-11-03
Thread-0的日期：2000-01-01转化日期后出错：1999-12-31
Thread-1的日期：2000-01-02转化日期后出错：1999-11-03
Thread-2的日期：2000-01-03转化日期后出错：1999-11-03

package com.newwork.tandashi;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * 
 * @author tandashi
 * 使用ThreadLocal 存放 SimpleDateFormat 
 */
public class MyThreadTwo extends Thread{
 private SimpleDateFormat sdf;
 private String dateString;
 public MyThreadTwo(SimpleDateFormat sdf,String dateString){
	 this.sdf = sdf;
	 this.dateString = dateString;
 }
 
 @Override
	public void run() {
	 try {
		SimpleDateFormat sdf = DateTools.getSimpleDateFormat("yyyy-MM-dd");
		Date newDate = sdf.parse(dateString);
		String newDateString = sdf.format(newDate).toString();
		if(!newDateString.equals(dateString)){
			System.out.println(this.getName() +"的日期："+dateString +"转换后出错："+newDateString);
		}
	} catch (ParseException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
 }
}

package com.newwork.tandashi;

import java.text.SimpleDateFormat;

public class DateTools {
	private static ThreadLocal<SimpleDateFormat> t1 = new ThreadLocal<SimpleDateFormat>();
	
	public static SimpleDateFormat getSimpleDateFormat(String pattern){
		SimpleDateFormat sdf = null;
		sdf = t1.get();
		if(sdf == null){
			sdf = new SimpleDateFormat(pattern);
			t1.set(sdf);
		}
		return sdf;
	}

}

package com.newwork.tandashi;

import java.text.SimpleDateFormat;

public class ThredTest2 {
	public static void main(String[] args) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String[] dateString = new String[]{"2000-01-01","2000-01-02","2000-01-03","2010-10-01"};
		MyThreadTwo[] thread = new MyThreadTwo[4];
		
		for (int i = 0; i < thread.length; i++) {
			thread[i]  = new MyThreadTwo(sdf,dateString[i]);
		}
		for (int i = 0; i < thread.length; i++) {
			thread[i].start();
		}
	}
}

public class SimpleDateFormatDemo {

    private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";

    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<>();

    /**
     * 获取线程的变量副本，如果不覆盖initialValue方法，第一次get将返回null,故需要创建一个DateFormat，放入threadLocal中
     * @return
     */
    public DateFormat getDateFormat() {
        DateFormat df = threadLocal.get();
        if (df == null) {
            df = new SimpleDateFormat(DATE_FORMAT);
            threadLocal.set(df);
        }
        return df;
    }

    public static void main(String [] args) {
        SimpleDateFormatDemo formatDemo = new SimpleDateFormatDemo();

        MyRunnable myRunnable1 = new MyRunnable(formatDemo);
        MyRunnable myRunnable2 = new MyRunnable(formatDemo);
        MyRunnable myRunnable3 = new MyRunnable(formatDemo);

        Thread thread1= new Thread(myRunnable1);
        Thread thread2= new Thread(myRunnable2);
        Thread thread3= new Thread(myRunnable3);
        thread1.start();
        thread2.start();
        thread3.start();
    }


    public static class MyRunnable implements Runnable {

        private SimpleDateFormatDemo dateFormatDemo;

        public MyRunnable(SimpleDateFormatDemo dateFormatDemo) {
            this.dateFormatDemo = dateFormatDemo;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+" 当前时间："+dateFormatDemo.getDateFormat().format(new Date()));
        }
    }
}

public class ThreadLocal<T> {   
/**  
     * ThreadLocals rely on per-thread hash maps attached to each thread  
     * (Thread.threadLocals and inheritableThreadLocals).  The ThreadLocal  
     * objects act as keys, searched via threadLocalHashCode.  This is a  
     * custom hash code (useful only within ThreadLocalMaps) that eliminates  
     * collisions in the common case where consecutively constructed  
     * ThreadLocals are used by the same threads, while remaining well-behaved  
     * in less common cases.  
     */  
    private final int threadLocalHashCode = nextHashCode();   
  
    /**  
     * The next hash code to be given out. Accessed only by like-named method.  
     */  
    private static int nextHashCode = 0;   
  
    /**  
     * The difference between successively generated hash codes - turns  
     * implicit sequential thread-local IDs into near-optimally spread  
     * multiplicative hash values for power-of-two-sized tables.  
     */  
    private static final int HASH_INCREMENT = 0x61c88647;   
  
    /**  
     * Compute the next hash code. The static synchronization used here  
     * should not be a performance bottleneck. When ThreadLocals are  
     * generated in different threads at a fast enough rate to regularly  
     * contend on this lock, memory contention is by far a more serious  
     * problem than lock contention.  
     */  
    private static synchronized int nextHashCode() {   
        int h = nextHashCode;   
        nextHashCode = h + HASH_INCREMENT;   
        return h;   
    }   
  
    /**  
     * Creates a thread local variable.  
     */  
    public ThreadLocal() {   
    }   
  
    /**  
     * Returns the value in the current thread‘s copy of this thread-local  
     * variable.  Creates and initializes the copy if this is the first time  
     * the thread has called this method.  
     *  
     * @return the current thread‘s value of this thread-local  
     */  
    public T get() {   
        Thread t = Thread.currentThread();   
        ThreadLocalMap map = getMap(t);   
        if (map != null)   
            return (T)map.get(this);   
  
        // Maps are constructed lazily.  if the map for this thread   
        // doesn‘t exist, create it, with this ThreadLocal and its   
        // initial value as its only entry.   
        T value = initialValue();   
        createMap(t, value);   
        return value;   
    }   
  
    /**  
     * Sets the current thread‘s copy of this thread-local variable  
     * to the specified value.  Many applications will have no need for  
     * this functionality, relying solely on the {@link #initialValue}  
     * method to set the values of thread-locals.  
     *  
     * @param value the value to be stored in the current threads‘ copy of  
     *        this thread-local.  
     */  
    public void set(T value) {   
        Thread t = Thread.currentThread();   
        ThreadLocalMap map = getMap(t);   
        if (map != null)   
            map.set(this, value);   
        else  
            createMap(t, value);   
    }   
  
    /**  
     * Get the map associated with a ThreadLocal. Overridden in  
     * InheritableThreadLocal.  
     *  
     * @param  t the current thread  
     * @return the map  
     */  
    ThreadLocalMap getMap(Thread t) {   
        return t.threadLocals;   
    }   
  
    /**  
     * Create the map associated with a ThreadLocal. Overridden in  
     * InheritableThreadLocal.  
     *  
     * @param t the current thread  
     * @param firstValue value for the initial entry of the map  
     * @param map the map to store.  
     */  
    void createMap(Thread t, T firstValue) {   
        t.threadLocals = new ThreadLocalMap(this, firstValue);   
    }   
  
    .......   
  
    /**  
     * ThreadLocalMap is a customized hash map suitable only for  
     * maintaining thread local values. No operations are exported  
     * outside of the ThreadLocal class. The class is package private to  
     * allow declaration of fields in class Thread.  To help deal with  
     * very large and long-lived usages, the hash table entries use  
     * WeakReferences for keys. However, since reference queues are not  
     * used, stale entries are guaranteed to be removed only when  
     * the table starts running out of space.  
     */  
    static class ThreadLocalMap {   
  
    ......
  
    }   
  
}  

private final int threadLocalHashCode = nextHashCode();
private static int nextHashCode = 0;
private static final int HASH_INCREMENT = 0x61c88647;