项目记事【多线程】：关于 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);
     }

 }

DateUtil

　　问题出在什么地方？就出在一个共享的变量 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();
         }
     }

 }

DateFormatTest

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

解决方案：

　　这种问题，不仅仅会出现在 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);
     }

 }

DateUtil1

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

第二类解决方案：

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

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);
         }
     }

 }

DateUtil2

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);
     }

 }

DateUtil3

第三类解决方案：