项目记事【多线程】：关于 SimpledDateFormat 的多线程问题

背景：

　　最近项目引入了 SonarLink，解决代码规范的问题，在检查历史代码的时候，发现了一个问题。

　　先看代码：

public class DateUtil {

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

    private static SimpleDateFormat sdf1 = new SimpleDateFormat(DATE_FORMAT_1);
    private static SimpleDateFormat sdf2 = new SimpleDateFormat(DATE_FORMAT_2);

    private DateUtil() {

    }

    public static String formatDate1(Date date) throws ParseException {
        return sdf1.format(date);
    }

    public static String formatDate2(Date date) throws ParseException {
        return sdf2.format(date);
    }

    public static Date parseDate1(String dateStr) throws ParseException {
        return sdf1.parse(dateStr);
    }

    public static Date parseDate2(String dateStr) throws ParseException {
        return sdf2.parse(dateStr);
    }

}

　　问题出在什么地方？就出在一个共享的变量 SimpledDateFormat，本身是一个线程不安全的类（由于内部实现使用了 Calendar），导致在多线程情况下可能出错。

多线程检测：

public class DateFormatTest {

    public static class TestSimpleDateFormatThreadSafe extends Thread {

        @Override
        public void run() {
            while (true) {
                try {
                    this.join(1000);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                try {
                    System.out.println(this.getName() + ":" + DateUtil.parseDate1("2013-05-24 06:02:20"));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
        }
    }

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

}

　　执行结果如下图（多次执行，出现的结果可能不同）：

解决方案：

　　这种问题，不仅仅会出现在 SimpleDateFormat 中，只能说 SimpleDateFormat 比较常见，具有代表性。

　　只要是将一个线程不安全类产生的实例作为共享变量，都有可能出现多线程的问题。

　　出现这类问题，应该从以下3个角度考虑解决方案：

1. 规避将一个线程不安全的对象，作为共享变量的情况。
2. 从多线程的角度考虑，解决线程安全问题。
3. 不使用线程不安全的对象，找一个拥有相同功能的其他类，作为替代方案。

第一类解决方案：

　　不要将线程不安全的对象，作为共享变量，在方法内部调用的时候再初始化这个对象。

　　代码如下：

public class DateUtil1 {

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

    private DateUtil1() {

    }

    public static String formatDate1(Date date) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_1);
        return sdf.format(date);
    }

    public static String formatDate2(Date date) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_2);
        return sdf.format(date);
    }

    public static Date parseDate1(String dateStr) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_1);
        return sdf.parse(dateStr);
    }

    public static Date parseDate2(String dateStr) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_2);
        return sdf.parse(dateStr);
    }

}

　　很显然，大多数情况下，都不会采用这个方案，频繁地创建-销毁对象，对于内存的影响非常大。

第二类解决方案：

　　从多线程的角度，就是说在使用这个线程不安全类的时候，加以控制，从以下两个角度入手：

1. 时间换空间：同步锁 synchronized。
2. 空间换时间：独立线程 ThreadLocal。

synchronized

　　使用 synchronized 的思路很简单，在使用线程不安全变量之前，先将这个变量用 synchronized 关键字锁住。

　　每一次其他线程使用这个变量时，会等待上一个线程释放这个锁之后再执行。

　　很明显，在高并发的情况下，这种方案对于时间的消耗很大。

　　代码如下：

public final class DateUtil2 {

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

    private static final SimpleDateFormat SDF_1 = new SimpleDateFormat(DATE_FORMAT_1);
    private static final SimpleDateFormat SDF_2 = new SimpleDateFormat(DATE_FORMAT_2);

    private DateUtil2() {

    }

    public static String formatDate1(Date date) throws ParseException {
        synchronized (SDF_1) {
            return SDF_1.format(date);
        }
    }

    public static String formatDate2(Date date) throws ParseException {
        synchronized (SDF_2) {
            return SDF_2.format(date);
        }
    }

    public static Date parseDate1(String dateStr) throws ParseException {
        synchronized (SDF_1) {
            return SDF_1.parse(dateStr);
        }
    }

    public static Date parseDate2(String dateStr) throws ParseException {
        synchronized (SDF_2) {
            return SDF_2.parse(dateStr);
        }
    }

}

ThreadLocal

　　ThreadLocal，可以简单地这么理解，ThreadLocal 为每一个使用这个线程的变量创建一个独立的副本。

　　每一个线程都在自己内部改变这个变量，自然不会出现线程安全问题。

　　明显，这种方案对于内存空间，消耗极大。

　　代码如下：

public final class DateUtil3 {

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

    private static Map<String, ThreadLocal<SimpleDateFormat>> threadLocalMap;
    private static List<String> dateFormatStringList;

    private DateUtil3() {

    }

    static {
        threadLocalMap = new HashMap<>();
        dateFormatStringList = new ArrayList<>();
        dateFormatStringList.add(DATE_FORMAT_1);
        dateFormatStringList.add(DATE_FORMAT_2);
        for (final String s : dateFormatStringList) {
            SimpleDateFormat sdf = new SimpleDateFormat(s);
            ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>() {
                @Override
                protected SimpleDateFormat initialValue() {
                    return new SimpleDateFormat(s);
                }
            };
            threadLocal.set(sdf);
            threadLocalMap.put(s, threadLocal);
        }
    }

    public static String formatDate1(Date date) throws ParseException {
        SimpleDateFormat sdf = threadLocalMap.get(DATE_FORMAT_1).get();
        return sdf.format(date);
    }

    public static String formatDate2(Date date) throws ParseException {
        SimpleDateFormat sdf = threadLocalMap.get(DATE_FORMAT_2).get();
        return sdf.format(date);
    }

    public static Date parseDate1(String dateStr) throws ParseException {
        SimpleDateFormat sdf = threadLocalMap.get(DATE_FORMAT_1).get();
        return sdf.parse(dateStr);
    }

    public static Date parseDate2(String dateStr) throws ParseException {
        SimpleDateFormat sdf = threadLocalMap.get(DATE_FORMAT_2).get();
        return sdf.parse(dateStr);
    }

}

第三类解决方案：