大家好，我是冰河~~

首先问下大家：你使用的SimpleDateFormat类还安全吗？为什么说SimpleDateFormat类不是线程安全的？带着问题从本文中寻求答案。

提起SimpleDateFormat类，想必做过Java开发的童鞋都不会感到陌生。没错，它就是Java中提供的日期时间的转化类。这里，为什么说SimpleDateFormat类有线程安全问题呢？有些小伙伴可能会提出疑问：我们生产环境上一直在使用SimpleDateFormat类来解析和格式化日期和时间类型的数据，一直都没有问题啊！我的回答是：没错，那是因为你们的系统达不到SimpleDateFormat类出现问题的并发量，也就是说你们的系统没啥负载！

接下来，我们就一起看下在高并发下SimpleDateFormat类为何会出现安全问题，以及如何解决SimpleDateFormat类的安全问题。

重现SimpleDateFormat类的线程安全问题

为了重现SimpleDateFormat类的线程安全问题，一种比较简单的方式就是使用线程池结合Java并发包中的CountDownLatch类和Semaphore类来重现线程安全问题。

有关CountDownLatch类和Semaphore类的具体用法和底层原理与源码解析在【高并发专题】后文会深度分析。这里，大家只需要知道CountDownLatch类可以使一个线程等待其他线程各自执行完毕后再执行。而Semaphore类可以理解为一个计数信号量，必须由获取它的线程释放，经常用来限制访问某些资源的线程数量，例如限流等。

好了，先来看下重现SimpleDateFormat类的线程安全问题的代码，如下所示。

  1. package io.binghe.concurrent.lab06;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.concurrent.CountDownLatch;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import java.util.concurrent.Semaphore;
  10. /**
  11.  * @author binghe
  12.  * @version 1.0.0
  13.  * @description 测试SimpleDateFormat的线程不安全问题
  14.  */
  15. public class SimpleDateFormatTest01 {
  16.     //执行总次数
  17.     private static final int EXECUTE_COUNT = 1000;
  18.     //同时运行的线程数量
  19.     private static final int THREAD_COUNT = 20;
  20.     //SimpleDateFormat对象
  21.     private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
  23.     public static void main(String[] args) throws InterruptedException {
  24.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  25.         final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
  26.         ExecutorService executorService = Executors.newCachedThreadPool();
  27.         for (int i = 0; i < EXECUTE_COUNT; i++){
  28.             executorService.execute(() -> {
  29.                 try {
  30.                     semaphore.acquire();
  31.                     try {
  32.                         simpleDateFormat.parse("2020-01-01");
  33.                     } catch (ParseException e) {
  34.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  35.                         e.printStackTrace();
  36.                         System.exit(1);
  37.                     }catch (NumberFormatException e){
  38.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  39.                         e.printStackTrace();
  40.                         System.exit(1);
  41.                     }
  42.                     semaphore.release();
  43.                 } catch (InterruptedException e) {
  44.                     System.out.println("信号量发生错误");
  45.                     e.printStackTrace();
  46.                     System.exit(1);
  47.                 }
  48.                 countDownLatch.countDown();
  49.             });
  50.         }
  51.         countDownLatch.await();
  52.         executorService.shutdown();
  53.         System.out.println("所有线程格式化日期成功");
  54.     }
  55. }

可以看到，在SimpleDateFormatTest01类中，首先定义了两个常量，一个是程序执行的总次数，一个是同时运行的线程数量。程序中结合线程池和CountDownLatch类与Semaphore类来模拟高并发的业务场景。其中，有关日期转化的代码只有如下一行。

  1. simpleDateFormat.parse("2020-01-01");

当程序捕获到异常时，打印相关的信息，并退出整个程序的运行。当程序正确运行后，会打印“所有线程格式化日期成功”。

运行程序输出的结果信息如下所示。

  1. Exception in thread "pool-1-thread-4" Exception in thread "pool-1-thread-1" Exception in thread "pool-1-thread-2" 线程：pool-1-thread-7 格式化日期失败
  2. 线程：pool-1-thread-9 格式化日期失败
  3. 线程：pool-1-thread-10 格式化日期失败
  4. Exception in thread "pool-1-thread-3" Exception in thread "pool-1-thread-5" Exception in thread "pool-1-thread-6" 线程：pool-1-thread-15 格式化日期失败
  5. 线程：pool-1-thread-21 格式化日期失败
  6. Exception in thread "pool-1-thread-23" 线程：pool-1-thread-16 格式化日期失败
  7. 线程：pool-1-thread-11 格式化日期失败
  8. java.lang.ArrayIndexOutOfBoundsException
  9. 线程：pool-1-thread-27 格式化日期失败
  10. 	at java.lang.System.arraycopy(Native Method)
  11. 	at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:597)
  12. 	at java.lang.StringBuffer.append(StringBuffer.java:367)
  13. 	at java.text.DigitList.getLong(DigitList.java:191)线程：pool-1-thread-25 格式化日期失败
  15. 	at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
  16. 	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
  17. 	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
  18. 线程：pool-1-thread-14 格式化日期失败
  19. 	at java.text.DateFormat.parse(DateFormat.java:364)
  20. 	at io.binghe.concurrent.lab06.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:47)
  21. 线程：pool-1-thread-13 格式化日期失败	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
  22. 	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
  24. 	at java.lang.Thread.run(Thread.java:748)
  25. java.lang.NumberFormatException: For input string: ""
  26. 	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
  27. 线程：pool-1-thread-20 格式化日期失败	at java.lang.Long.parseLong(Long.java:601)
  28. 	at java.lang.Long.parseLong(Long.java:631)
  30. 	at java.text.DigitList.getLong(DigitList.java:195)
  31. 	at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
  32. 	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2162)
  33. 	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
  34. 	at java.text.DateFormat.parse(DateFormat.java:364)
  35. 	at io.binghe.concurrent.lab06.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:47)
  36. 	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
  37. 	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
  38. 	at java.lang.Thread.run(Thread.java:748)
  39. java.lang.NumberFormatException: For input string: ""
  40. 	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
  41. 	at java.lang.Long.parseLong(Long.java:601)
  42. 	at java.lang.Long.parseLong(Long.java:631)
  43. 	at java.text.DigitList.getLong(DigitList.java:195)
  44. 	at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
  45. 	at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
  46. 	at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
  47. 	at java.text.DateFormat.parse(DateFormat.java:364)
  49. Process finished with exit code 1

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

接下来，我们就看下，SimpleDateFormat类为何不是线程安全的。

SimpleDateFormat类为何不是线程安全的？

那么，接下来，我们就一起来看看真正引起SimpleDateFormat类线程不安全的根本原因。

通过查看SimpleDateFormat类的源码，我们得知：SimpleDateFormat是继承自DateFormat类，DateFormat类中维护了一个全局的Calendar变量，如下所示。

  1. /**
  2.   * The {@link Calendar} instance used for calculating the date-time fields
  3.   * and the instant of time. This field is used for both formatting and
  4.   * parsing.
  5.   *
  6.   * <p>Subclasses should initialize this field to a {@link Calendar}
  7.   * appropriate for the {@link Locale} associated with this
  8.   * <code>DateFormat</code>.
  9.   * @serial
  10.   */
  11. protected Calendar calendar;

从注释可以看出，这个Calendar对象既用于格式化也用于解析日期时间。接下来，我们再查看parse()方法接近最后的部分。

  1. @Override
  2. public Date parse(String text, ParsePosition pos){
  3.     ################此处省略N行代码##################
  4.     Date parsedDate;
  5.     try {
  6.         parsedDate = calb.establish(calendar).getTime();
  7.         // If the year value is ambiguous,
  8.         // then the two-digit year == the default start year
  9.         if (ambiguousYear[0]) {
  10.             if (parsedDate.before(defaultCenturyStart)) {
  11.                 parsedDate = calb.addYear(100).establish(calendar).getTime();
  12.             }
  13.         }
  14.     }
  15.     // An IllegalArgumentException will be thrown by Calendar.getTime()
  16.     // if any fields are out of range, e.g., MONTH == 17.
  17.     catch (IllegalArgumentException e) {
  18.         pos.errorIndex = start;
  19.         pos.index = oldStart;
  20.         return null;
  21.     }
  22.     return parsedDate;
  23. }

可见，最后的返回值是通过调用CalendarBuilder.establish()方法获得的，而这个方法的参数正好就是前面的Calendar对象。

接下来，我们再来看看CalendarBuilder.establish()方法，如下所示。

  1. Calendar establish(Calendar cal) {
  2.     boolean weekDate = isSet(WEEK_YEAR)
  3.         && field[WEEK_YEAR] > field[YEAR];
  4.     if (weekDate && !cal.isWeekDateSupported()) {
  5.         // Use YEAR instead
  6.         if (!isSet(YEAR)) {
  7.             set(YEAR, field[MAX_FIELD + WEEK_YEAR]);
  8.         }
  9.         weekDate = false;
  10.     }
  12.     cal.clear();
  13.     // Set the fields from the min stamp to the max stamp so that
  14.     // the field resolution works in the Calendar.
  15.     for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
  16.         for (int index = 0; index <= maxFieldIndex; index++) {
  17.             if (field[index] == stamp) {
  18.                 cal.set(index, field[MAX_FIELD + index]);
  19.                 break;
  20.             }
  21.         }
  22.     }
  24.     if (weekDate) {
  25.         int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
  26.         int dayOfWeek = isSet(DAY_OF_WEEK) ?
  27.             field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
  28.         if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
  29.             if (dayOfWeek >= 8) {
  30.                 dayOfWeek--;
  31.                 weekOfYear += dayOfWeek / 7;
  32.                 dayOfWeek = (dayOfWeek % 7) + 1;
  33.             } else {
  34.                 while (dayOfWeek <= 0) {
  35.                     dayOfWeek += 7;
  36.                     weekOfYear--;
  37.                 }
  38.             }
  39.             dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
  40.         }
  41.         cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);
  42.     }
  43.     return cal;
  44. }

在CalendarBuilder.establish()方法中先后调用了cal.clear()与cal.set()，也就是先清除cal对象中设置的值，再重新设置新的值。由于Calendar内部并没有线程安全机制，并且这两个操作也都不是原子性的，所以当多个线程同时操作一个SimpleDateFormat时就会引起cal的值混乱。类似地， format()方法也存在同样的问题。

因此， SimpleDateFormat类不是线程安全的根本原因是：DateFormat类中的Calendar对象被多线程共享，而Calendar对象本身不支持线程安全。

那么，得知了SimpleDateFormat类不是线程安全的，以及造成SimpleDateFormat类不是线程安全的原因，那么如何解决这个问题呢？接下来，我们就一起探讨下如何解决SimpleDateFormat类在高并发场景下的线程安全问题。

解决SimpleDateFormat类的线程安全问题

解决SimpleDateFormat类在高并发场景下的线程安全问题可以有多种方式，这里，就列举几个常用的方式供参考，大家也可以在评论区给出更多的解决方案。

1.局部变量法

最简单的一种方式就是将SimpleDateFormat类对象定义成局部变量，如下所示的代码，将SimpleDateFormat类对象定义在parse(String)方法的上面，即可解决问题。

  1. package io.binghe.concurrent.lab06;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.concurrent.CountDownLatch;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import java.util.concurrent.Semaphore;
  10. /**
  11.  * @author binghe
  12.  * @version 1.0.0
  13.  * @description 局部变量法解决SimpleDateFormat类的线程安全问题
  14.  */
  15. public class SimpleDateFormatTest02 {
  16.     //执行总次数
  17.     private static final int EXECUTE_COUNT = 1000;
  18.     //同时运行的线程数量
  19.     private static final int THREAD_COUNT = 20;
  21.     public static void main(String[] args) throws InterruptedException {
  22.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  23.         final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
  24.         ExecutorService executorService = Executors.newCachedThreadPool();
  25.         for (int i = 0; i < EXECUTE_COUNT; i++){
  26.             executorService.execute(() -> {
  27.                 try {
  28.                     semaphore.acquire();
  29.                     try {
  30.                         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
  31.                         simpleDateFormat.parse("2020-01-01");
  32.                     } catch (ParseException e) {
  33.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  34.                         e.printStackTrace();
  35.                         System.exit(1);
  36.                     }catch (NumberFormatException e){
  37.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  38.                         e.printStackTrace();
  39.                         System.exit(1);
  40.                     }
  41.                     semaphore.release();
  42.                 } catch (InterruptedException e) {
  43.                     System.out.println("信号量发生错误");
  44.                     e.printStackTrace();
  45.                     System.exit(1);
  46.                 }
  47.                 countDownLatch.countDown();
  48.             });
  49.         }
  50.         countDownLatch.await();
  51.         executorService.shutdown();
  52.         System.out.println("所有线程格式化日期成功");
  53.     }
  54. }

此时运行修改后的程序，输出结果如下所示。

  1. 所有线程格式化日期成功

至于在高并发场景下使用局部变量为何能解决线程的安全问题，会在【JVM专题】的JVM内存模式相关内容中深入剖析，这里不做过多的介绍了。

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

2.synchronized锁方式

将SimpleDateFormat类对象定义成全局静态变量，此时所有线程共享SimpleDateFormat类对象，此时在调用格式化时间的方法时，对SimpleDateFormat对象进行同步即可，代码如下所示。

  1. package io.binghe.concurrent.lab06;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.concurrent.CountDownLatch;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import java.util.concurrent.Semaphore;
  10. /**
  11.  * @author binghe
  12.  * @version 1.0.0
  13.  * @description 通过Synchronized锁解决SimpleDateFormat类的线程安全问题
  14.  */
  15. public class SimpleDateFormatTest03 {
  16.     //执行总次数
  17.     private static final int EXECUTE_COUNT = 1000;
  18.     //同时运行的线程数量
  19.     private static final int THREAD_COUNT = 20;
  20.     //SimpleDateFormat对象
  21.     private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
  23.     public static void main(String[] args) throws InterruptedException {
  24.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  25.         final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
  26.         ExecutorService executorService = Executors.newCachedThreadPool();
  27.         for (int i = 0; i < EXECUTE_COUNT; i++){
  28.             executorService.execute(() -> {
  29.                 try {
  30.                     semaphore.acquire();
  31.                     try {
  32.                         synchronized (simpleDateFormat){
  33.                             simpleDateFormat.parse("2020-01-01");
  34.                         }
  35.                     } catch (ParseException e) {
  36.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  37.                         e.printStackTrace();
  38.                         System.exit(1);
  39.                     }catch (NumberFormatException e){
  40.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  41.                         e.printStackTrace();
  42.                         System.exit(1);
  43.                     }
  44.                     semaphore.release();
  45.                 } catch (InterruptedException e) {
  46.                     System.out.println("信号量发生错误");
  47.                     e.printStackTrace();
  48.                     System.exit(1);
  49.                 }
  50.                 countDownLatch.countDown();
  51.             });
  52.         }
  53.         countDownLatch.await();
  54.         executorService.shutdown();
  55.         System.out.println("所有线程格式化日期成功");
  56.     }
  57. }

此时，解决问题的关键代码如下所示。

  1. synchronized (simpleDateFormat){
  2. 	simpleDateFormat.parse("2020-01-01");
  3. }

运行程序，输出结果如下所示。

  1. 所有线程格式化日期成功

需要注意的是，虽然这种方式能够解决SimpleDateFormat类的线程安全问题，但是由于在程序的执行过程中，为SimpleDateFormat类对象加上了synchronized锁，导致同一时刻只能有一个线程执行parse(String)方法。此时，会影响程序的执行性能，在要求高并发的生产环境下，此种方式也是不太推荐使用的。

3.Lock锁方式

Lock锁方式与synchronized锁方式实现原理相同，都是在高并发下通过JVM的锁机制来保证程序的线程安全。通过Lock锁方式解决问题的代码如下所示。

  1. package io.binghe.concurrent.lab06;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.concurrent.CountDownLatch;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import java.util.concurrent.Semaphore;
  9. import java.util.concurrent.locks.Lock;
  10. import java.util.concurrent.locks.ReentrantLock;
  12. /**
  13.  * @author binghe
  14.  * @version 1.0.0
  15.  * @description 通过Lock锁解决SimpleDateFormat类的线程安全问题
  16.  */
  17. public class SimpleDateFormatTest04 {
  18.     //执行总次数
  19.     private static final int EXECUTE_COUNT = 1000;
  20.     //同时运行的线程数量
  21.     private static final int THREAD_COUNT = 20;
  22.     //SimpleDateFormat对象
  23.     private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
  24.     //Lock对象
  25.     private static Lock lock = new ReentrantLock();
  27.     public static void main(String[] args) throws InterruptedException {
  28.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  29.         final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
  30.         ExecutorService executorService = Executors.newCachedThreadPool();
  31.         for (int i = 0; i < EXECUTE_COUNT; i++){
  32.             executorService.execute(() -> {
  33.                 try {
  34.                     semaphore.acquire();
  35.                     try {
  36.                         lock.lock();
  37.                         simpleDateFormat.parse("2020-01-01");
  38.                     } catch (ParseException e) {
  39.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  40.                         e.printStackTrace();
  41.                         System.exit(1);
  42.                     }catch (NumberFormatException e){
  43.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  44.                         e.printStackTrace();
  45.                         System.exit(1);
  46.                     }finally {
  47.                         lock.unlock();
  48.                     }
  49.                     semaphore.release();
  50.                 } catch (InterruptedException e) {
  51.                     System.out.println("信号量发生错误");
  52.                     e.printStackTrace();
  53.                     System.exit(1);
  54.                 }
  55.                 countDownLatch.countDown();
  56.             });
  57.         }
  58.         countDownLatch.await();
  59.         executorService.shutdown();
  60.         System.out.println("所有线程格式化日期成功");
  61.     }
  62. }

通过代码可以得知，首先，定义了一个Lock类型的全局静态变量作为加锁和释放锁的句柄。然后在simpleDateFormat.parse(String)代码之前通过lock.lock()加锁。这里需要注意的一点是：为防止程序抛出异常而导致锁不能被释放，一定要将释放锁的操作放到finally代码块中，如下所示。

  1. finally {
  2. 	lock.unlock();
  3. }

运行程序，输出结果如下所示。

  1. 所有线程格式化日期成功

此种方式同样会影响高并发场景下的性能，不太建议在高并发的生产环境使用。

4.ThreadLocal方式

使用ThreadLocal存储每个线程拥有的SimpleDateFormat对象的副本，能够有效的避免多线程造成的线程安全问题，使用ThreadLocal解决线程安全问题的代码如下所示。

  1. package io.binghe.concurrent.lab06;
  3. import java.text.DateFormat;
  4. import java.text.ParseException;
  5. import java.text.SimpleDateFormat;
  6. import java.util.concurrent.CountDownLatch;
  7. import java.util.concurrent.ExecutorService;
  8. import java.util.concurrent.Executors;
  9. import java.util.concurrent.Semaphore;
  11. /**
  12.  * @author binghe
  13.  * @version 1.0.0
  14.  * @description 通过ThreadLocal解决SimpleDateFormat类的线程安全问题
  15.  */
  16. public class SimpleDateFormatTest05 {
  17.     //执行总次数
  18.     private static final int EXECUTE_COUNT = 1000;
  19.     //同时运行的线程数量
  20.     private static final int THREAD_COUNT = 20;
  22.     private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
  23.         @Override
  24.         protected DateFormat initialValue() {
  25.             return new SimpleDateFormat("yyyy-MM-dd");
  26.         }
  27.     };
  29.     public static void main(String[] args) throws InterruptedException {
  30.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  31.         final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
  32.         ExecutorService executorService = Executors.newCachedThreadPool();
  33.         for (int i = 0; i < EXECUTE_COUNT; i++){
  34.             executorService.execute(() -> {
  35.                 try {
  36.                     semaphore.acquire();
  37.                     try {
  38.                         threadLocal.get().parse("2020-01-01");
  39.                     } catch (ParseException e) {
  40.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  41.                         e.printStackTrace();
  42.                         System.exit(1);
  43.                     }catch (NumberFormatException e){
  44.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  45.                         e.printStackTrace();
  46.                         System.exit(1);
  47.                     }
  48.                     semaphore.release();
  49.                 } catch (InterruptedException e) {
  50.                     System.out.println("信号量发生错误");
  51.                     e.printStackTrace();
  52.                     System.exit(1);
  53.                 }
  54.                 countDownLatch.countDown();
  55.             });
  56.         }
  57.         countDownLatch.await();
  58.         executorService.shutdown();
  59.         System.out.println("所有线程格式化日期成功");
  60.     }
  61. }

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

运行程序，输出结果如下所示。

  1. 所有线程格式化日期成功

此种方式运行效率比较高，推荐在高并发业务场景的生产环境使用。

另外，使用ThreadLocal也可以写成如下形式的代码，效果是一样的。

  1. package io.binghe.concurrent.lab06;
  3. import java.text.DateFormat;
  4. import java.text.ParseException;
  5. import java.text.SimpleDateFormat;
  6. import java.util.concurrent.CountDownLatch;
  7. import java.util.concurrent.ExecutorService;
  8. import java.util.concurrent.Executors;
  9. import java.util.concurrent.Semaphore;
  11. /**
  12.  * @author binghe
  13.  * @version 1.0.0
  14.  * @description 通过ThreadLocal解决SimpleDateFormat类的线程安全问题
  15.  */
  16. public class SimpleDateFormatTest06 {
  17.     //执行总次数
  18.     private static final int EXECUTE_COUNT = 1000;
  19.     //同时运行的线程数量
  20.     private static final int THREAD_COUNT = 20;
  22.     private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>();
  24.     private static DateFormat getDateFormat(){
  25.         DateFormat dateFormat = threadLocal.get();
  26.         if(dateFormat == null){
  27.             dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  28.             threadLocal.set(dateFormat);
  29.         }
  30.         return dateFormat;
  31.     }
  33.     public static void main(String[] args) throws InterruptedException {
  34.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  35.         final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
  36.         ExecutorService executorService = Executors.newCachedThreadPool();
  37.         for (int i = 0; i < EXECUTE_COUNT; i++){
  38.             executorService.execute(() -> {
  39.                 try {
  40.                     semaphore.acquire();
  41.                     try {
  42.                         getDateFormat().parse("2020-01-01");
  43.                     } catch (ParseException e) {
  44.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  45.                         e.printStackTrace();
  46.                         System.exit(1);
  47.                     }catch (NumberFormatException e){
  48.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  49.                         e.printStackTrace();
  50.                         System.exit(1);
  51.                     }
  52.                     semaphore.release();
  53.                 } catch (InterruptedException e) {
  54.                     System.out.println("信号量发生错误");
  55.                     e.printStackTrace();
  56.                     System.exit(1);
  57.                 }
  58.                 countDownLatch.countDown();
  59.             });
  60.         }
  61.         countDownLatch.await();
  62.         executorService.shutdown();
  63.         System.out.println("所有线程格式化日期成功");
  64.     }
  65. }

5.DateTimeFormatter方式

DateTimeFormatter是Java8提供的新的日期时间API中的类，DateTimeFormatter类是线程安全的，可以在高并发场景下直接使用DateTimeFormatter类来处理日期的格式化操作。代码如下所示。

  1. package io.binghe.concurrent.lab06;
  3. import java.time.LocalDate;
  4. import java.time.format.DateTimeFormatter;
  5. import java.util.concurrent.CountDownLatch;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import java.util.concurrent.Semaphore;
  10. /**
  11.  * @author binghe
  12.  * @version 1.0.0
  13.  * @description 通过DateTimeFormatter类解决线程安全问题
  14.  */
  15. public class SimpleDateFormatTest07 {
  16.     //执行总次数
  17.     private static final int EXECUTE_COUNT = 1000;
  18.     //同时运行的线程数量
  19.     private static final int THREAD_COUNT = 20;
  21.    private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
  23.     public static void main(String[] args) throws InterruptedException {
  24.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  25.         final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
  26.         ExecutorService executorService = Executors.newCachedThreadPool();
  27.         for (int i = 0; i < EXECUTE_COUNT; i++){
  28.             executorService.execute(() -> {
  29.                 try {
  30.                     semaphore.acquire();
  31.                     try {
  32.                         LocalDate.parse("2020-01-01", formatter);
  33.                     }catch (Exception e){
  34.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  35.                         e.printStackTrace();
  36.                         System.exit(1);
  37.                     }
  38.                     semaphore.release();
  39.                 } catch (InterruptedException e) {
  40.                     System.out.println("信号量发生错误");
  41.                     e.printStackTrace();
  42.                     System.exit(1);
  43.                 }
  44.                 countDownLatch.countDown();
  45.             });
  46.         }
  47.         countDownLatch.await();
  48.         executorService.shutdown();
  49.         System.out.println("所有线程格式化日期成功");
  50.     }
  51. }

可以看到，DateTimeFormatter类是线程安全的，可以在高并发场景下直接使用DateTimeFormatter类来处理日期的格式化操作。

运行程序，输出结果如下所示。

  1. 所有线程格式化日期成功

使用DateTimeFormatter类来处理日期的格式化操作运行效率比较高，推荐在高并发业务场景的生产环境使用。

6.joda-time方式

joda-time是第三方处理日期时间格式化的类库，是线程安全的。如果使用joda-time来处理日期和时间的格式化，则需要引入第三方类库。这里，以Maven为例，如下所示引入joda-time库。

  1. <dependency>
  2. 	<groupId>joda-time</groupId>
  3. 	<artifactId>joda-time</artifactId>
  4. 	<version>2.9.9</version>
  5. </dependency>

引入joda-time库后，实现的程序代码如下所示。

  1. package io.binghe.concurrent.lab06;
  3. import org.joda.time.DateTime;
  4. import org.joda.time.format.DateTimeFormat;
  5. import org.joda.time.format.DateTimeFormatter;
  7. import java.util.concurrent.CountDownLatch;
  8. import java.util.concurrent.ExecutorService;
  9. import java.util.concurrent.Executors;
  10. import java.util.concurrent.Semaphore;
  12. /**
  13.  * @author binghe
  14.  * @version 1.0.0
  15.  * @description 通过DateTimeFormatter类解决线程安全问题
  16.  */
  17. public class SimpleDateFormatTest08 {
  18.     //执行总次数
  19.     private static final int EXECUTE_COUNT = 1000;
  20.     //同时运行的线程数量
  21.     private static final int THREAD_COUNT = 20;
  23.     private static DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyy-MM-dd");
  25.     public static void main(String[] args) throws InterruptedException {
  26.         final Semaphore semaphore = new Semaphore(THREAD_COUNT);
  27.         final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
  28.         ExecutorService executorService = Executors.newCachedThreadPool();
  29.         for (int i = 0; i < EXECUTE_COUNT; i++){
  30.             executorService.execute(() -> {
  31.                 try {
  32.                     semaphore.acquire();
  33.                     try {
  34.                         DateTime.parse("2020-01-01", dateTimeFormatter).toDate();
  35.                     }catch (Exception e){
  36.                         System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
  37.                         e.printStackTrace();
  38.                         System.exit(1);
  39.                     }
  40.                     semaphore.release();
  41.                 } catch (InterruptedException e) {
  42.                     System.out.println("信号量发生错误");
  43.                     e.printStackTrace();
  44.                     System.exit(1);
  45.                 }
  46.                 countDownLatch.countDown();
  47.             });
  48.         }
  49.         countDownLatch.await();
  50.         executorService.shutdown();
  51.         System.out.println("所有线程格式化日期成功");
  52.     }
  53. }

这里，需要注意的是：DateTime类是org.joda.time包下的类，DateTimeFormat类和DateTimeFormatter类都是org.joda.time.format包下的类，如下所示。

  1. import org.joda.time.DateTime;
  2. import org.joda.time.format.DateTimeFormat;
  3. import org.joda.time.format.DateTimeFormatter;

运行程序，输出结果如下所示。

  1. 所有线程格式化日期成功

使用joda-time库来处理日期的格式化操作运行效率比较高，推荐在高并发业务场景的生产环境使用。

解决SimpleDateFormat类的线程安全问题的方案总结

综上所示：在解决解决SimpleDateFormat类的线程安全问题的几种方案中，局部变量法由于线程每次执行格式化时间时，都会创建SimpleDateFormat类的对象，这会导致创建大量的SimpleDateFormat对象，浪费运行空间和消耗服务器的性能，因为JVM创建和销毁对象是要耗费性能的。所以，不推荐在高并发要求的生产环境使用。

synchronized锁方式和Lock锁方式在处理问题的本质上是一致的，通过加锁的方式，使同一时刻只能有一个线程执行格式化日期和时间的操作。这种方式虽然减少了SimpleDateFormat对象的创建，但是由于同步锁的存在，导致性能下降，所以，不推荐在高并发要求的生产环境使用。

ThreadLocal通过保存各个线程的SimpleDateFormat类对象的副本，使每个线程在运行时，各自使用自身绑定的SimpleDateFormat对象，互不干扰，执行性能比较高，推荐在高并发的生产环境使用。

DateTimeFormatter是Java 8中提供的处理日期和时间的类，DateTimeFormatter类本身就是线程安全的，经压测，DateTimeFormatter类处理日期和时间的性能效果还不错（后文单独写一篇关于高并发下性能压测的文章）。所以，推荐在高并发场景下的生产环境使用。

joda-time是第三方处理日期和时间的类库，线程安全，性能经过高并发的考验，推荐在高并发场景下的生产环境使用。

好了，今天就到这儿吧，我是冰河，我们下期见~~

好了，今天就到这儿吧，小伙伴们点赞、收藏、评论，一键三连走起呀，我是冰河，我们下期见~~

【高并发】SimpleDateFormat类到底为啥不是线程安全的？（附六种解决方案，建议收藏）的更多相关文章

  1. Qunar机票技术部就有一个全年很关键的一个指标：搜索缓存命中率，当时已经做到了>99.7%。再往后，每提高0.1%，优化难度成指数级增长了。哪怕是千分之一，也直接影响用户体验，影响每天上万张机票的销售额。 在高并发场景下，提供了保证线程安全的对象、方法。比如经典的ConcurrentHashMap，它比起HashMap，有更小粒度的锁，并发读写性能更好。线程安全的StringBuilder取代S

    Qunar机票技术部就有一个全年很关键的一个指标:搜索缓存命中率,当时已经做到了>99.7%.再往后,每提高0.1%,优化难度成指数级增长了.哪怕是千分之一,也直接影响用户体验,影响每天上万张机 ...

  2. java高并发系列 - 第31天：获取线程执行结果，这6种方法你都知道？

    这是java高并发系列第31篇. 环境:jdk1.8. java高并发系列已经学了不少东西了,本篇文章,我们用前面学的知识来实现一个需求: 在一个线程中需要获取其他线程的执行结果,能想到几种方式?各有 ...

  3. Mysql在高并发情况下，防止库存超卖而小于0的解决方案

    背景: 本人上次做申领campaign的PHP后台时,因为项目上线后某些时段同时申领的人过多,导致一些专柜的存货为负数(<0),还好并发量不是特别大,只存在于小部分专柜而且一般都是-1的状况,没 ...

  4. Java并发工具类（四）：线程间交换数据的Exchanger

    简介 Exchanger(交换者)是一个用于线程间协作的工具类.Exchanger用于进行线程间的数据交换.它提供一个同步点,在这个同步点两个线程可以交换彼此的数据.这两个线程通过exchange方法 ...

  5. java高并发核心类 AQS(Abstract Queued Synchronizer）抽象队列同步器

    什么是AQS? 全称: Abstract Queued Synchronizer: 抽象队列同步器 是 java.util.concurrent.locks包下的一个抽象类 其编写者: Doug Le ...

  6. 【高并发】通过源码深度分析线程池中Worker线程的执行流程

    大家好,我是冰河~~ 在<高并发之--通过ThreadPoolExecutor类的源码深度解析线程池执行任务的核心流程>一文中我们深度分析了线程池执行任务的核心流程,在ThreadPool ...

  7. java高并发系列 - 第14天：JUC中的LockSupport工具类，必备技能

    这是java高并发系列第14篇文章. 本文主要内容: 讲解3种让线程等待和唤醒的方法,每种方法配合具体的示例 介绍LockSupport主要用法 对比3种方式,了解他们之间的区别 LockSuppor ...

  8. java高并发系列 - 第15天：JUC中的Semaphore，最简单的限流工具类，必备技能

    这是java高并发系列第15篇文章 Semaphore(信号量)为多线程协作提供了更为强大的控制方法,前面的文章中我们学了synchronized和重入锁ReentrantLock,这2种锁一次都只能 ...

  9. java高并发系列 - 第16天：JUC中等待多线程完成的工具类CountDownLatch，必备技能

    这是java高并发系列第16篇文章. 本篇内容 介绍CountDownLatch及使用场景 提供几个示例介绍CountDownLatch的使用 手写一个并行处理任务的工具类 假如有这样一个需求,当我们 ...

  10. java高并发系列 - 第22天：java中底层工具类Unsafe，高手必须要了解

    这是java高并发系列第22篇文章,文章基于jdk1.8环境. 本文主要内容 基本介绍. 通过反射获取Unsafe实例 Unsafe中的CAS操作 Unsafe中原子操作相关方法介绍 Unsafe中线 ...

随机推荐

  1. #PowerBi 1分钟学会，以“万”为单位显示数据

    PowerBi是一款强大的数据分析和可视化工具,它可以帮助我们快速地制作出各种图表和报表,展示数据的价值和洞察. 但是,有时候我们的数据量太大,导致图表上的数字难以阅读和比较.例如,如果我们想要查看某 ...

  2. java英文字符串首字母大写

    java英文字符串首字母大写 /** * 首字母大写 * @param string * @return */ public static String toUpperCase4Index(Strin ...

  3. jenkins的安装和配置(flask结合jenkins半自动化部署流程)

    jenkins在虚拟机中安装 1.1 背景介绍 Jenkins 是一款流行的开源持续集成(Continuous Integration)工具,广泛用于项目开发,具有自动化构建.测试和部署等功能. Je ...

  4. 2020-12-02：mysql中，一张表里面有 ID 自增主键，当 insert 了 17 条记录之后，删除了第 15,16,17 条记录，再把 Mysql 重启，再 insert 一条记录，这条记

    2020-12-02:mysql中,一张表里面有 ID 自增主键,当 insert 了 17 条记录之后,删除了第 15,16,17 条记录,再把 Mysql 重启,再 insert 一条记录,这条记 ...

  5. 2021-04-19：手写代码：最小生成树算法之Kruskal。

    2021-04-19:手写代码:最小生成树算法之Kruskal. 福大大 答案2021-04-19: 并查集.边从小到大,找最小边,无环. 代码用golang编写.代码如下: package main ...

  6. 2021-07-05：股票问题2。给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖

    2021-07-05:股票问题2.给定一个数组 prices ,其中 prices[i] 是一支给定股票第 i 天的价格.设计一个算法来计算你所能获取的最大利润.你可以尽可能地完成更多的交易(多次买卖 ...

  7. L2-004 这是二叉搜索树吗？ (25 分)

    1.题目描述: 一棵二叉搜索树可被递归地定义为具有下列性质的二叉树:对于任一结点, 其左子树中所有结点的键值小于该结点的键值: 其右子树中所有结点的键值大于等于该结点的键值: 其左右子树都是二叉搜索树 ...

  8. 代码随想录算法训练营Day31 贪心算法| 122.买卖股票的最佳时机II 55. 跳跃游戏 45.跳跃游戏II

    代码随想录算法训练营 122.买卖股票的最佳时机II 题目链接:122.买卖股票的最佳时机II 给定一个数组,它的第 i个元素是一支给定股票第 i 天的价格. 设计一个算法来计算你所能获取的最大利润. ...

  9. jquery页面搜索关键词突出显示

    页面搜索关键词突出 // 页面搜索关键词突出 $(function () { $(".list_r").find('span').css({ // 每次搜索开始,先把所有字体颜色恢 ...

  10. 20230611 再次升级SSD

    家里常用电脑的硬盘又显得捉襟见肘,老规矩,升级SSD.幸亏几年前摸索的方法记录下来了,翻出以前的博客复习一下.为了保险起见,也重新在网上搜了一下,看是不是有新的更方便的方法,答案是没有,只是搜出很多推 ...