SimpleDateFormat在多线程下存在并发安全问题。

1.重现SimpleDateFormat类的线程安全问题

  1. /**
  2.  *
  3.  * 重现SimpleDateFormat类的线程安全问题
  4.  *
  5.  * @author 二十
  6.  * @since 2021/9/12 10:05 下午
  7.  */
  8. public class SdfTest {
  9.     /**执行总次数*/
  10.     private static final int EXECUTE_COUNT=1000;
  11.     /**并发线程数*/
  12.     private static final int THREAD_COUNT=100;
  14.     private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  17.     @Test
  18.     public void test()throws Exception{
  19.         final Semaphore semaphore =new Semaphore(THREAD_COUNT);
  21.         final CountDownLatch cdl = new CountDownLatch(EXECUTE_COUNT);
  23.         ExecutorService executor = Executors.newCachedThreadPool();
  25.         for (int i = 0; i < EXECUTE_COUNT; i++) {
  26.             executor.execute(()->{
  27.                 try {
  28.                     semaphore.acquire();
  29.                     sdf.parse("2021-09-15");
  31.                 }catch (Exception e){
  32.                     System.out.println(Thread.currentThread().getName()+"格式化时间失败！");
  33.                 }finally {
  34.                     semaphore.release();
  35.                     cdl.countDown();
  36.                 }
  37.             });
  38.         }
  39.         cdl.await();
  40.         executor.shutdown();
  41.     }
  42. }

说明：在高并发下使用SimpleDateFormat类格式化日期的时候抛出了异常，SimpleDateFormat类不是线程安全的！ 为什么SimpleDateFormat不是线程安全的？

2.SimpleDateFormat为什么不是线程安全的？

  1. public Date parse(String source) throws ParseException
  2.     {
  3.         ParsePosition pos = new ParsePosition(0);
  4.         //调用了parse方法，最终的实现类在SimpleDateFormat类中
  5.         Date result = parse(source, pos);
  6.         if (pos.index == 0)
  7.             throw new ParseException("Unparseable date: \"" + source + "\"" ,
  8.                 pos.errorIndex);
  9.         return result;
  10. }

点进去parse()，这是一个抽象的方法。

  1. public abstract Date parse(String source, ParsePosition pos);

最终的实现类还是在SimpleDateFormat类中。

  1. public Date parse(String text, ParsePosition pos)
  2. {
  3.     checkNegativeNumberExpression();
  5.     int start = pos.index;
  6.     int oldStart = start;
  7.     int textLength = text.length();
  9.     boolean[] ambiguousYear = {false};
  11.     CalendarBuilder calb = new CalendarBuilder();
  13.     for (int i = 0; i < compiledPattern.length; ) {
  14.         int tag = compiledPattern[i] >>> 8;
  15.         int count = compiledPattern[i++] & 0xff;
  16.         if (count == 255) {
  17.             count = compiledPattern[i++] << 16;
  18.             count |= compiledPattern[i++];
  19.         }
  21.         switch (tag) {
  22.             case TAG_QUOTE_ASCII_CHAR:
  23.                 if (start >= textLength || text.charAt(start) != (char)count) {
  24.                     //破坏了线程的安全性
  25.                     pos.index = oldStart;
  26.                     //破坏了线程的安全性
  27.                     pos.errorIndex = start;
  28.                     return null;
  29.                 }
  30.                 start++;
  31.                 break;
  33.             case TAG_QUOTE_CHARS:
  34.                 while (count-- > 0) {
  35.                     if (start >= textLength || text.charAt(start) != compiledPattern[i++]) {
  36.                         pos.index = oldStart;//破坏了线程的安全性
  37.                         pos.errorIndex = start;//破坏了线程的安全性
  38.                         return null;
  39.                     }
  40.                     start++;
  41.                 }
  42.                 break;
  44.             default:
  46.                 boolean obeyCount = false;
  48.                 boolean useFollowingMinusSignAsDelimiter = false;
  50.                 if (i < compiledPattern.length) {
  51.                     int nextTag = compiledPattern[i] >>> 8;
  52.                     if (!(nextTag == TAG_QUOTE_ASCII_CHAR ||
  53.                           nextTag == TAG_QUOTE_CHARS)) {
  54.                         obeyCount = true;
  55.                     }
  57.                     if (hasFollowingMinusSign &&
  58.                         (nextTag == TAG_QUOTE_ASCII_CHAR ||
  59.                          nextTag == TAG_QUOTE_CHARS)) {
  60.                         int c;
  61.                         if (nextTag == TAG_QUOTE_ASCII_CHAR) {
  62.                             c = compiledPattern[i] & 0xff;
  63.                         } else {
  64.                             c = compiledPattern[i+1];
  65.                         }
  67.                         if (c == minusSign) {
  68.                             useFollowingMinusSignAsDelimiter = true;
  69.                         }
  70.                     }
  71.                 }
  72.                 start = subParse(text, start, tag, count, obeyCount,
  73.                                  ambiguousYear, pos,
  74.                                  useFollowingMinusSignAsDelimiter, calb);
  75.                 if (start < 0) {
  76.                     //破坏了线程的安全性
  77.                     pos.index = oldStart;
  78.                     return null;
  79.                 }
  80.         }
  81.     }
  82.     //破坏了线程的安全性
  83.     pos.index = start;
  85.     Date parsedDate;
  86.     try {
  87.         parsedDate = calb.establish(calendar).getTime();
  89.         if (ambiguousYear[0]) {
  90.             if (parsedDate.before(defaultCenturyStart)) {
  91.                 parsedDate = calb.addYear(100).establish(calendar).getTime();
  92.             }
  93.         }
  94.     }
  96.     catch (IllegalArgumentException e) {
  97.         //破坏了线程的安全性
  98.         pos.errorIndex = start;
  99.         //破坏了线程的安全性
  100.         pos.index = oldStart;
  101.         return null;
  102.     }
  104.     return parsedDate;
  105. }

通过对SimpleDateFormat类中的parse()进行分析可以得知：parse()中存在几处为ParsePosition类中的索引赋值的操作。

一旦将SimpleDateFormat类定义成全局静态变量，那么SimpleDateFormat类在多线程之间是共享的，这就会导致ParsePosition类在多线程之间共享。

在高并发场景下，一个线程对ParsePosition类中的索引进行修改，一定会影响到其他线程对ParsePosition类中索引的读。这就造成了线程的安全问题。

那么在确定了SimpleDateFormat线程不安全的原因以后，如何来解决这个问题。

3.SimpleDateFormat类线程安全的解决

3.1 局部变量法

  1. public class SdfTest {
  2.     /**执行总次数*/
  3.     private static final int EXECUTE_COUNT=1000;
  4.     /**并发线程数*/
  5.     private static final int THREAD_COUNT=100;
  8.     @Test
  9.     public void test()throws Exception{
  10.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  11.         final Semaphore semaphore =new Semaphore(THREAD_COUNT);
  13.         final CountDownLatch cdl = new CountDownLatch(EXECUTE_COUNT);
  15.         ExecutorService executor = Executors.newCachedThreadPool();
  17.         for (int i = 0; i < EXECUTE_COUNT; i++) {
  18.             executor.execute(()->{
  19.                 try {
  20.                     semaphore.acquire();
  21.                     sdf.parse("2021-09-15");
  23.                 }catch (Exception e){
  24.                     System.out.println(Thread.currentThread().getName()+"格式化时间失败！");
  25.                 }finally {
  26.                     semaphore.release();
  27.                     cdl.countDown();
  28.                 }
  29.             });
  30.         }
  31.         cdl.await();
  32.         executor.shutdown();
  33.     }
  34. }

这种方式在高并发场景下会创建大量的SimpleDateFormat对象，影响程序的性能，所以，这种方式在实际生产环境不太推荐。

3.2 synchronized

  1. public class SdfTest {
  2.     /**执行总次数*/
  3.     private static final int EXECUTE_COUNT=1000;
  4.     /**并发线程数*/
  5.     private static final int THREAD_COUNT=100;
  7.     private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");;
  8.     @Test
  9.     public void test()throws Exception{
  11.         final Semaphore semaphore =new Semaphore(THREAD_COUNT);
  13.         final CountDownLatch cdl = new CountDownLatch(EXECUTE_COUNT);
  15.         ExecutorService executor = Executors.newCachedThreadPool();
  17.         for (int i = 0; i < EXECUTE_COUNT; i++) {
  18.             executor.execute(()->{
  19.                 try {
  20.                     semaphore.acquire();
  21.                     synchronized (sdf){
  22.                         sdf.parse("2021-09-15");
  23.                     }
  24.                 }catch (Exception e){
  25.                     System.out.println(Thread.currentThread().getName()+"格式化时间失败！");
  26.                 }finally {
  27.                     semaphore.release();
  28.                     cdl.countDown();
  29.                 }
  30.             });
  31.         }
  32.         cdl.await();
  33.         executor.shutdown();
  34.     }
  35. }

这种方式解决了他的线程安全问题，但是程序在执行的过程中，为SimpleDateFormat类对象加了synchronized锁，导致在同一时刻只能由一个线程执行格式化时间的方法。此时会影响程序的性能，在要求高并发的生产环境下，此种方式也是不太推荐使用的。

3.3 Lock锁方式

  1. public class SdfTest {
  2.     /**
  3.      * 执行总次数
  4.      */
  5.     private static final int EXECUTE_COUNT = 1000;
  6.     /**
  7.      * 并发线程数
  8.      */
  9.     private static final int THREAD_COUNT = 100;
  11.     private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  13.     private static Lock lock = new ReentrantLock();
  15.     @Test
  16.     public void test() throws Exception {
  18.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  20.         final CountDownLatch cdl = new CountDownLatch(EXECUTE_COUNT);
  22.         ExecutorService executor = Executors.newCachedThreadPool();
  24.         for (int i = 0; i < EXECUTE_COUNT; i++) {
  25.             executor.execute(() -> {
  26.                 try {
  27.                     semaphore.acquire();
  28.                     lock.lock();
  29.                     try {
  30.                         sdf.parse("2021-09-15");
  31.                     } finally {
  32.                         lock.unlock();
  33.                     }
  34.                 } catch (Exception e) {
  35.                     System.out.println(Thread.currentThread().getName() + "格式化时间失败！");
  36.                 } finally {
  38.                     semaphore.release();
  39.                     cdl.countDown();
  40.                 }
  41.             });
  42.         }
  43.         cdl.await();
  44.         executor.shutdown();
  45.     }
  46. }

通过代码得知：首先定义了Lock类型的全局静态变量作为加锁和释放锁的句柄。然后再SimpleDateFormat.parse()代码执行之前加锁。

这里需要注意的一点是：为了防止程序抛出异常而导致锁不能被释放，一定要将释放锁的操作放到finally代码块。

此种方式在并发下同样影响性能，不太推荐在高并发生产中使用。

3.4ThreadLocal方式

  1. public class SdfTest {
  2.     /**
  3.      * 执行总次数
  4.      */
  5.     private static final int EXECUTE_COUNT = 1000;
  6.     /**
  7.      * 并发线程数
  8.      */
  9.     private static final int THREAD_COUNT = 100;
  11.     private static ThreadLocal<DateFormat> threadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
  13.     @Test
  14.     public void test() throws Exception {
  16.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  18.         final CountDownLatch cdl = new CountDownLatch(EXECUTE_COUNT);
  20.         ExecutorService executor = Executors.newCachedThreadPool();
  22.         for (int i = 0; i < EXECUTE_COUNT; i++) {
  23.             executor.execute(() -> {
  24.                 try {
  25.                     semaphore.acquire();
  26.                     threadLocal.get().parse("2021-09-15");
  27.                 } catch (Exception e) {
  28.                     System.out.println(Thread.currentThread().getName() + "格式化时间失败！");
  29.                 } finally {
  30.                     threadLocal.remove();
  31.                     semaphore.release();
  32.                     cdl.countDown();
  33.                 }
  34.             });
  35.         }
  36.         cdl.await();
  37.         executor.shutdown();
  38.     }
  39. }

使用ThreadLocal将每个线程使用的SimpleDateFormat副本保存在ThreadLocal中，各个线程在使用时互不干扰，从而解决了线程安全的问题。

此种方式运行效率比较高，推荐在高并发场景下使用。

3.5 DateTimeFormatter

jdk8线程安全的时间日期API。