分析非线程安全SimpleDateFormat以及使用改进优化方案

SimpleDateFormat 是非线程安全的

我们经常使用一些单例处理的实例作为工具类基础，然而SimpleDateFormat的单例实例在在并发情况下回出现各种灵异错误。
原因是因为SimpleDateFormat不是线程安全的。我们之所以忽视线程安全的问题，是因为从SimpleDateFormat提供的接口看不出来它是非线程安全的
只是在JDK文档的类注释有如下说明： Date formats are not synchronized.
推荐（建议）为每个线程创建独立的格式实例。如果多个线程同时访问一个格式，则它必须保持外部同步

 * </table>
 * </blockquote>
 *
 * <h4><a name="synchronization">Synchronization</a></h4>
 *
 * <p>
 * Date formats are not synchronized.
 * It is recommended to create separate format instances for each thread.
 * If multiple threads access a format concurrently, it must be synchronized
 * externally.
 *
 * @see          <a href="https://docs.oracle.com/javase/tutorial/i18n/format/simpleDateFormat.html">Java Tutorial</a>
 * @see          java.util.Calendar
 * @see          java.util.TimeZone
 * @see          DateFormat
 * @see          DateFormatSymbols
 * @author       Mark Davis, Chen-Lieh Huang, Alan Liu
 */
public class SimpleDateFormat extends DateFormat {

SimpleDateFormat继承了DateFormat,在DateFormat中定义了一个protected属性的 Calendar类的对象：calendar
Calendar类的的功能牵扯到时区与本地化等等，Jdk的实现中使用了成员变量来传递参数，这就造成在多线程的时候会出现错误。

// Called from Format after creating a FieldDelegate
    private StringBuffer format(Date date, StringBuffer toAppendTo,
                                FieldDelegate delegate) {
        // Convert input date to time field list
        calendar.setTime(date);

        boolean useDateFormatSymbols = useDateFormatSymbols();

        for (int i = 0; i < compiledPattern.length; ) {
            int tag = compiledPattern[i] >>> 8;
            int count = compiledPattern[i++] & 0xff;
            if (count == 255) {
                count = compiledPattern[i++] << 16;
                count |= compiledPattern[i++];
            }

            switch (tag) {
            case TAG_QUOTE_ASCII_CHAR:
                toAppendTo.append((char)count);
                break;

            case TAG_QUOTE_CHARS:
                toAppendTo.append(compiledPattern, i, count);
                i += count;
                break;

            default:
                subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);
                break;
            }
        }
        return toAppendTo;
    }

线程不安全原因分析：

calendar.setTime(date)这条语句改变了calendar，稍后，calendar还会用到（在subFormat方法里），而这就是引发问题的根源。想象一下，在一个多线程环境下，有两个线程持有了同一个SimpleDateFormat的实例，分别调用format方法：
1. 线程1进来,调用format方法，改变了calendar
2. 中断
3. 线程2进来，开始执行，改变了calendar
4. 中断
5. 回到线程1，此时，calendar已然不是它所设的值，而是走上了线程2设计的道路。

• 结论：如果多个线程同时争抢calendar对象，则会出现各种问题，时间不对，线程挂死等等。而SimpleDateFormat的实现用到成员变量calendar，唯一的好处，就是在调用subFormat时，少了一个参数，却带来了这许多的问题。

这里要提到的就是如何判断线程安全的方法标准了：那便是无状态，如果方法里面存在状态，并且可以被改变的情况的话，开发者就必须要考虑并发情况下的线程安全问题了

无状态方法的好处之一，就是它在各种环境下，都可以安全的调用。衡量一个方法是否是有状态的，就看它是否改动了其它的东西，比如全局变量，比如实例的字段。format方法在运行过程中改动了SimpleDateFormat的calendar字段，所以，它是有状态的。

开发过程中使用SimpleDateFormat的线程安全的使用方案

1. 需要的时候创建新实例，对实例内存什么的不存在太多要求的小应用推荐使用
2. 使用synchronized：同步SimpleDateFormat对象，缺点，高并发并发下存在性能问题
3. 使用ThreadLocal将共享变量变为线程独享
4. 抛弃JDK，使用其他类库中的时间格式化类：推荐Apache commons 里的FastDateForma 以及 Joda-Time类库

以下是测试代码：

package cn.coremail;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author linbingcheng
 * @version V1.0
 * @Title: UnsafeDateUtils
 * @Description: TODO
 * @email bclin@coremail.cn
 * @date 2018/6/26
 */
public class UnsafeDateUtils {

//    public static  String formatDate(Date date)throws ParseException {
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        return sdf.format(date);
//    }
//
//    public static Date parse(String strDate) throws ParseException{
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        return sdf.parse(strDate);
//    }

    private static final  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static  String formatDate(Date date)throws ParseException{
        return sdf.format(date);
    }

    public static Date parse(String strDate) throws ParseException{

        return sdf.parse(strDate);
    }
}

package cn.coremail;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @author linbingcheng
 * @version V1.0
 * @Title: SafeDateUtils
 * @Description: TODO
 * @email bclin@coremail.cn
 * @date 2018/7/3
 */
public class SafeDateUtils  {

    /** 锁对象 */
    private static final Object lockObj = new Object();
    private static Map<String, ThreadLocal<SimpleDateFormat>> sdfMap = new HashMap<String, ThreadLocal<SimpleDateFormat>>();

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

    private static SimpleDateFormat getSdf(final String pattern) {
        ThreadLocal<SimpleDateFormat> tl = sdfMap.get(pattern);
        // 此处的双重判断和同步是为了防止sdfMap这个单例被多次put重复的sdf
        if (tl == null) {
            synchronized (lockObj) {
                tl = sdfMap.get(pattern);
                if (tl == null) {
                    // 这里是关键,使用ThreadLocal<SimpleDateFormat>替代原来直接new SimpleDateFormat
                    tl = new ThreadLocal<SimpleDateFormat>() {
                        @Override
                        protected SimpleDateFormat initialValue() {
                            return new SimpleDateFormat(pattern);
                        }
                    };
                    sdfMap.put(pattern, tl);
                }
            }
        }

        return tl.get();
    }

    public static String formatDate(Date date, String pattern) throws ParseException {
        return getSdf(pattern).format(date);
    }

    public static Date parse(String strDate, String pattern) throws ParseException {
        return getSdf(pattern).parse(strDate);
    }
}


package cn.coremail;

import java.text.ParseException;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author linbingcheng
 * @version V1.0
 * @Title: DateUtilTest
 * @Description: TODO
 * @email bclin@coremail.cn
 * @date 2018/6/26
 */
public class DateUtilTest {

    static CyclicBarrier cyclicBarrier =  new CyclicBarrier(5);

    public static class TestSimpleDateFormatThreadSafe extends Thread {
        @Override
        public void run() {
            System.out.println(this.getName() + ": is running");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            while(true) {
                try {
//                    System.out.println(this.getName() + ":" + UnsafeDateUtils.parse("2018-06-24 06:02:20 "));
                    System.out.println(this.getName() + ":" + SafeDateUtils.parse("2018-06-24 06:02:20 ","yyyy-MM-dd HH:mm:ss"));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                try {
                    this.join(1000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                yield();
            }
        }
    }


    public static void main(String[] args) {
        for(int i = 0; i < 5; i++){
            new TestSimpleDateFormatThreadSafe().start();
        }
    }
}