Simple Date Format類到底爲啥不是線程安全的？

原創 原創 2023-06-05 10:54
摘要：我們就一起看下在高併發下Simple Date Format類爲何會出現安全問題，以及如何解決Simple Date Format類的安全問題。

本文分享自華爲雲社區《【高併發】SimpleDateFormat類到底爲啥不是線程安全的？》，作者：冰 河。

首先問下大家：你使用的Simple Date Format類還安全嗎？爲什麼說Simple Date Format 類不是線程安全的？帶着問題從本文中尋求答案。

提起Simple Date Format 類，想必做過Java開發的童鞋都不會感到陌生。沒錯，它就是Java中提供的日期時間的轉化類。這裏，爲什麼說Simple Date Format 類有線程安全問題呢？有些小夥伴可能會提出疑問：我們生產環境上一直在使用Simple Date Format 類來解析和格式化日期和時間類型的數據，一直都沒有問題啊！我的回答是：沒錯，那是因爲你們的系統達不到Simple Date Format 類出現問題的併發量，也就是說你們的系統沒啥負載！

接下來，我們就一起看下在高併發下Simple Date Format 類爲何會出現安全問題，以及如何解決 Simple Date Format 類的安全問題。

重現 Simple Date Format類的線程安全問題

爲了重現Simple Date Format類的線程安全問題，一種比較簡單的方式就是使用線程池結合Java併發包中的Count Down Latch類和Semaphore類來重現線程安全問題。

有關Count Down Latch 類和Semaphore類的具體用法和底層原理與源碼解析在【高併發專題】後文會深度分析。這裏，大家只需要知道 Count Down Latch 類可以使一個線程等待其他線程各自執行完畢後再執行。而Semaphore類可以理解爲一個計數信號量，必須由獲取它的線程釋放，經常用來限制訪問某些資源的線程數量，例如限流等。

好了，先來看下重現Simple Date Format 類的線程安全問題的代碼，如下所示。

package io.binghe.concurrent.lab06;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * @author binghe
 * @version 1.0.0
 * @description 測試SimpleDateFormat的線程不安全問題
 */
public class SimpleDateFormatTest01 {
 //執行總次數
 private static final int EXECUTE_COUNT = 1000;
 //同時運行的線程數量
 private static final int THREAD_COUNT = 20;
 //SimpleDateFormat對象
 private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
 public static void main(String[] args) throws InterruptedException {
 final Semaphore semaphore = new Semaphore(THREAD_COUNT);
 final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < EXECUTE_COUNT; i++){
 executorService.execute(() -> {
 try {
 semaphore.acquire();
 try {
 simpleDateFormat.parse("2020-01-01");
 } catch (ParseException e) {
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }catch (NumberFormatException e){
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }
 semaphore.release();
 } catch (InterruptedException e) {
 System.out.println("信號量發生錯誤");
 e.printStackTrace();
 System.exit(1);
 }
 countDownLatch.countDown();
 });
 }
 countDownLatch.await();
 executorService.shutdown();
 System.out.println("所有線程格式化日期成功");
 }
}

可以看到，在SimpleDateFormatTest01類中，首先定義了兩個常量，一個是程序執行的總次數，一個是同時運行的線程數量。程序中結合線程池和Count Down Latch類與Semaphore類來模擬高併發的業務場景。其中，有關日期轉化的代碼只有如下一行。

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

當程序捕獲到異常時，打印相關的信息，並退出整個程序的運行。當程序正確運行後，會打印“所有線程格式化日期成功”。

運行程序輸出的結果信息如下所示。

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 格式化日期失敗
線程：pool-1-thread-9 格式化日期失敗
線程：pool-1-thread-10 格式化日期失敗
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 格式化日期失敗
線程：pool-1-thread-21 格式化日期失敗
Exception in thread "pool-1-thread-23" 線程：pool-1-thread-16 格式化日期失敗
線程：pool-1-thread-11 格式化日期失敗
java.lang.ArrayIndexOutOfBoundsException
線程：pool-1-thread-27 格式化日期失敗
at java.lang.System.arraycopy(Native Method)
at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:597)
at java.lang.StringBuffer.append(StringBuffer.java:367)
at java.text.DigitList.getLong(DigitList.java:191)線程：pool-1-thread-25 格式化日期失敗
at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
線程：pool-1-thread-14 格式化日期失敗
at java.text.DateFormat.parse(DateFormat.java:364)
at io.binghe.concurrent.lab06.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:47)
線程：pool-1-thread-13 格式化日期失敗at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:748)
java.lang.NumberFormatException: For input string: ""
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
線程：pool-1-thread-20 格式化日期失敗at java.lang.Long.parseLong(Long.java:601)
at java.lang.Long.parseLong(Long.java:631)
at java.text.DigitList.getLong(DigitList.java:195)
at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:2162)
at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
at java.text.DateFormat.parse(DateFormat.java:364)
at io.binghe.concurrent.lab06.SimpleDateFormatTest01.lambda$main$0(SimpleDateFormatTest01.java:47)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:748)
java.lang.NumberFormatException: For input string: ""
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Long.parseLong(Long.java:601)
at java.lang.Long.parseLong(Long.java:631)
at java.text.DigitList.getLong(DigitList.java:195)
at java.text.DecimalFormat.parse(DecimalFormat.java:2084)
at java.text.SimpleDateFormat.subParse(SimpleDateFormat.java:1869)
at java.text.SimpleDateFormat.parse(SimpleDateFormat.java:1514)
at java.text.DateFormat.parse(DateFormat.java:364)
Process finished with exit code 1

說明，在高併發下使用Simple Date Format 類格式化日期時拋出了異常，Simple Date Forma t類不是線程安全的！！！

接下來，我們就看下，Simple Date Format 類爲何不是線程安全的。

Simple Date Format 類爲何不是線程安全的？

那麼，接下來，我們就一起來看看真正引起Simple Date Format類線程不安全的根本原因。

通過查看Simple Date Format類的源碼，我們得知：Simple Date Format是繼承自Date Format類，Date Format類中維護了一個全局的Calendar變量，如下所示。

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

從註釋可以看出，這個Calendar對象既用於格式化也用於解析日期時間。接下來，我們再查看parse()方法接近最後的部分。

@Override
public Date parse(String text, ParsePosition pos){
    ################此處省略N行代碼##################
 Date parsedDate;
 try {
 parsedDate = calb.establish(calendar).getTime();
 // If the year value is ambiguous,
 // then the two-digit year == the default start year
 if (ambiguousYear[0]) {
 if (parsedDate.before(defaultCenturyStart)) {
 parsedDate = calb.addYear(100).establish(calendar).getTime();
 }
 }
 }
 // An IllegalArgumentException will be thrown by Calendar.getTime()
 // if any fields are out of range, e.g., MONTH == 17.
 catch (IllegalArgumentException e) {
 pos.errorIndex = start;
 pos.index = oldStart;
 return null;
 }
 return parsedDate;
}

可見，最後的返回值是通過調用CalendarBuilder.establish()方法獲得的，而這個方法的參數正好就是前面的Calendar對象。

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

Calendar establish(Calendar cal) {
 boolean weekDate = isSet(WEEK_YEAR)
 && field[WEEK_YEAR] > field[YEAR];
 if (weekDate && !cal.isWeekDateSupported()) {
 // Use YEAR instead
 if (!isSet(YEAR)) {
 set(YEAR, field[MAX_FIELD + WEEK_YEAR]);
 }
 weekDate = false;
 }
 cal.clear();
 // Set the fields from the min stamp to the max stamp so that
 // the field resolution works in the Calendar.
 for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
 for (int index = 0; index <= maxFieldIndex; index++) {
 if (field[index] == stamp) {
 cal.set(index, field[MAX_FIELD + index]);
 break;
 }
 }
 }
 if (weekDate) {
 int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
 int dayOfWeek = isSet(DAY_OF_WEEK) ?
 field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
 if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
 if (dayOfWeek >= 8) {
 dayOfWeek--;
 weekOfYear += dayOfWeek / 7;
 dayOfWeek = (dayOfWeek % 7) + 1;
 } else {
 while (dayOfWeek <= 0) {
 dayOfWeek += 7;
 weekOfYear--;
 }
 }
 dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
 }
 cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);
 }
 return cal;
}

在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)方法的上面，即可解決問題。

package io.binghe.concurrent.lab06;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * @author binghe
 * @version 1.0.0
 * @description 局部變量法解決SimpleDateFormat類的線程安全問題
 */
public class SimpleDateFormatTest02 {
 //執行總次數
 private static final int EXECUTE_COUNT = 1000;
 //同時運行的線程數量
 private static final int THREAD_COUNT = 20;
 public static void main(String[] args) throws InterruptedException {
 final Semaphore semaphore = new Semaphore(THREAD_COUNT);
 final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < EXECUTE_COUNT; i++){
 executorService.execute(() -> {
 try {
 semaphore.acquire();
 try {
 SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
 simpleDateFormat.parse("2020-01-01");
 } catch (ParseException e) {
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }catch (NumberFormatException e){
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }
 semaphore.release();
 } catch (InterruptedException e) {
 System.out.println("信號量發生錯誤");
 e.printStackTrace();
 System.exit(1);
 }
 countDownLatch.countDown();
 });
 }
 countDownLatch.await();
 executorService.shutdown();
 System.out.println("所有線程格式化日期成功");
 }
}

此時運行修改後的程序，輸出結果如下所示。

所有線程格式化日期成功

至於在高併發場景下使用局部變量爲何能解決線程的安全問題，會在【JVM專題】的JVM內存模式相關內容中深入剖析，這裏不做過多的介紹了。

當然，這種方式在高併發下會創建大量的SimpleDateFormat類對象，影響程序的性能，所以，這種方式在實際生產環境不太被推薦。

2.synchronized鎖方式

將SimpleDateFormat類對象定義成全局靜態變量，此時所有線程共享SimpleDateFormat類對象，此時在調用格式化時間的方法時，對SimpleDateFormat對象進行同步即可，代碼如下所示。

package io.binghe.concurrent.lab06;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * @author binghe
 * @version 1.0.0
 * @description 通過Synchronized鎖解決SimpleDateFormat類的線程安全問題
 */
public class SimpleDateFormatTest03 {
 //執行總次數
 private static final int EXECUTE_COUNT = 1000;
 //同時運行的線程數量
 private static final int THREAD_COUNT = 20;
 //SimpleDateFormat對象
 private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
 public static void main(String[] args) throws InterruptedException {
 final Semaphore semaphore = new Semaphore(THREAD_COUNT);
 final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < EXECUTE_COUNT; i++){
 executorService.execute(() -> {
 try {
 semaphore.acquire();
 try {
 synchronized (simpleDateFormat){
 simpleDateFormat.parse("2020-01-01");
 }
 } catch (ParseException e) {
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }catch (NumberFormatException e){
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }
 semaphore.release();
 } catch (InterruptedException e) {
 System.out.println("信號量發生錯誤");
 e.printStackTrace();
 System.exit(1);
 }
 countDownLatch.countDown();
 });
 }
 countDownLatch.await();
 executorService.shutdown();
 System.out.println("所有線程格式化日期成功");
 }
}

此時，解決問題的關鍵代碼如下所示。

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

運行程序，輸出結果如下所示。

所有線程格式化日期成功

需要注意的是，雖然這種方式能夠解決SimpleDateFormat類的線程安全問題，但是由於在程序的執行過程中，爲SimpleDateFormat類對象加上了synchronized鎖，導致同一時刻只能有一個線程執行parse(String)方法。此時，會影響程序的執行性能，在要求高併發的生產環境下，此種方式也是不太推薦使用的。

3.Lock鎖方式

Lock鎖方式與synchronized鎖方式實現原理相同，都是在高併發下通過JVM的鎖機制來保證程序的線程安全。通過Lock鎖方式解決問題的代碼如下所示。

package io.binghe.concurrent.lab06;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @author binghe
 * @version 1.0.0
 * @description 通過Lock鎖解決SimpleDateFormat類的線程安全問題
 */
public class SimpleDateFormatTest04 {
 //執行總次數
 private static final int EXECUTE_COUNT = 1000;
 //同時運行的線程數量
 private static final int THREAD_COUNT = 20;
 //SimpleDateFormat對象
 private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
 //Lock對象
 private static Lock lock = new ReentrantLock();
 public static void main(String[] args) throws InterruptedException {
 final Semaphore semaphore = new Semaphore(THREAD_COUNT);
 final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < EXECUTE_COUNT; i++){
 executorService.execute(() -> {
 try {
 semaphore.acquire();
 try {
 lock.lock();
 simpleDateFormat.parse("2020-01-01");
 } catch (ParseException e) {
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }catch (NumberFormatException e){
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }finally {
 lock.unlock();
 }
 semaphore.release();
 } catch (InterruptedException e) {
 System.out.println("信號量發生錯誤");
 e.printStackTrace();
 System.exit(1);
 }
 countDownLatch.countDown();
 });
 }
 countDownLatch.await();
 executorService.shutdown();
 System.out.println("所有線程格式化日期成功");
 }
}

通過代碼可以得知，首先，定義了一個Lock類型的全局靜態變量作爲加鎖和釋放鎖的句柄。然後在simpleDateFormat.parse(String)代碼之前通過lock.lock()加鎖。這裏需要注意的一點是：爲防止程序拋出異常而導致鎖不能被釋放，一定要將釋放鎖的操作放到finally代碼塊中，如下所示。

finally {
lock.unlock();
}

運行程序，輸出結果如下所示。

所有線程格式化日期成功

此種方式同樣會影響高併發場景下的性能，不太建議在高併發的生產環境使用。

4.ThreadLocal方式

使用ThreadLocal存儲每個線程擁有的SimpleDateFormat對象的副本，能夠有效的避免多線程造成的線程安全問題，使用ThreadLocal解決線程安全問題的代碼如下所示。

package io.binghe.concurrent.lab06;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * @author binghe
 * @version 1.0.0
 * @description 通過ThreadLocal解決SimpleDateFormat類的線程安全問題
 */
public class SimpleDateFormatTest05 {
 //執行總次數
 private static final int EXECUTE_COUNT = 1000;
 //同時運行的線程數量
 private static final int THREAD_COUNT = 20;
 private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
 @Override
 protected DateFormat initialValue() {
 return new SimpleDateFormat("yyyy-MM-dd");
 }
 };
 public static void main(String[] args) throws InterruptedException {
 final Semaphore semaphore = new Semaphore(THREAD_COUNT);
 final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < EXECUTE_COUNT; i++){
 executorService.execute(() -> {
 try {
 semaphore.acquire();
 try {
 threadLocal.get().parse("2020-01-01");
 } catch (ParseException e) {
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }catch (NumberFormatException e){
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }
 semaphore.release();
 } catch (InterruptedException e) {
 System.out.println("信號量發生錯誤");
 e.printStackTrace();
 System.exit(1);
 }
 countDownLatch.countDown();
 });
 }
 countDownLatch.await();
 executorService.shutdown();
 System.out.println("所有線程格式化日期成功");
 }
}

通過代碼可以得知，將每個線程使用的SimpleDateFormat副本保存在ThreadLocal中，各個線程在使用時互不干擾，從而解決了線程安全問題。

運行程序，輸出結果如下所示。

所有線程格式化日期成功

此種方式運行效率比較高，推薦在高併發業務場景的生產環境使用。

另外，使用ThreadLocal也可以寫成如下形式的代碼，效果是一樣的。

package io.binghe.concurrent.lab06;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * @author binghe
 * @version 1.0.0
 * @description 通過ThreadLocal解決SimpleDateFormat類的線程安全問題
 */
public class SimpleDateFormatTest06 {
 //執行總次數
 private static final int EXECUTE_COUNT = 1000;
 //同時運行的線程數量
 private static final int THREAD_COUNT = 20;
 private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>();
 private static DateFormat getDateFormat(){
 DateFormat dateFormat = threadLocal.get();
 if(dateFormat == null){
 dateFormat = new SimpleDateFormat("yyyy-MM-dd");
 threadLocal.set(dateFormat);
 }
 return dateFormat;
 }
 public static void main(String[] args) throws InterruptedException {
 final Semaphore semaphore = new Semaphore(THREAD_COUNT);
 final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < EXECUTE_COUNT; i++){
 executorService.execute(() -> {
 try {
 semaphore.acquire();
 try {
 getDateFormat().parse("2020-01-01");
 } catch (ParseException e) {
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }catch (NumberFormatException e){
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }
 semaphore.release();
 } catch (InterruptedException e) {
 System.out.println("信號量發生錯誤");
 e.printStackTrace();
 System.exit(1);
 }
 countDownLatch.countDown();
 });
 }
 countDownLatch.await();
 executorService.shutdown();
 System.out.println("所有線程格式化日期成功");
 }
}

5.DateTimeFormatter方式

DateTimeFormatter是Java8提供的新的日期時間API中的類，DateTimeFormatter類是線程安全的，可以在高併發場景下直接使用DateTimeFormatter類來處理日期的格式化操作。代碼如下所示。

package io.binghe.concurrent.lab06;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * @author binghe
 * @version 1.0.0
 * @description 通過DateTimeFormatter類解決線程安全問題
 */
public class SimpleDateFormatTest07 {
 //執行總次數
 private static final int EXECUTE_COUNT = 1000;
 //同時運行的線程數量
 private static final int THREAD_COUNT = 20;
 private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
 public static void main(String[] args) throws InterruptedException {
 final Semaphore semaphore = new Semaphore(THREAD_COUNT);
 final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < EXECUTE_COUNT; i++){
 executorService.execute(() -> {
 try {
 semaphore.acquire();
 try {
 LocalDate.parse("2020-01-01", formatter);
 }catch (Exception e){
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }
 semaphore.release();
 } catch (InterruptedException e) {
 System.out.println("信號量發生錯誤");
 e.printStackTrace();
 System.exit(1);
 }
 countDownLatch.countDown();
 });
 }
 countDownLatch.await();
 executorService.shutdown();
 System.out.println("所有線程格式化日期成功");
 }
}

可以看到，DateTimeFormatter類是線程安全的，可以在高併發場景下直接使用DateTimeFormatter類來處理日期的格式化操作。

運行程序，輸出結果如下所示。

所有線程格式化日期成功

使用DateTimeFormatter類來處理日期的格式化操作運行效率比較高，推薦在高併發業務場景的生產環境使用。

6.joda-time方式

joda-time是第三方處理日期時間格式化的類庫，是線程安全的。如果使用joda-time來處理日期和時間的格式化，則需要引入第三方類庫。這裏，以Maven爲例，如下所示引入joda-time庫。

<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>2.9.9</version>
</dependency>

引入joda-time庫後，實現的程序代碼如下所示。

package io.binghe.concurrent.lab06;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * @author binghe
 * @version 1.0.0
 * @description 通過DateTimeFormatter類解決線程安全問題
 */
public class SimpleDateFormatTest08 {
 //執行總次數
 private static final int EXECUTE_COUNT = 1000;
 //同時運行的線程數量
 private static final int THREAD_COUNT = 20;
 private static DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyy-MM-dd");
 public static void main(String[] args) throws InterruptedException {
 final Semaphore semaphore = new Semaphore(THREAD_COUNT);
 final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < EXECUTE_COUNT; i++){
 executorService.execute(() -> {
 try {
 semaphore.acquire();
 try {
 DateTime.parse("2020-01-01", dateTimeFormatter).toDate();
 }catch (Exception e){
 System.out.println("線程：" + Thread.currentThread().getName() + " 格式化日期失敗");
 e.printStackTrace();
 System.exit(1);
 }
 semaphore.release();
 } catch (InterruptedException e) {
 System.out.println("信號量發生錯誤");
 e.printStackTrace();
 System.exit(1);
 }
 countDownLatch.countDown();
 });
 }
 countDownLatch.await();
 executorService.shutdown();
 System.out.println("所有線程格式化日期成功");
 }
}

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

import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

運行程序，輸出結果如下所示。

所有線程格式化日期成功

使用joda-time庫來處理日期的格式化操作運行效率比較高，推薦在高併發業務場景的生產環境使用。

解決SimpleDateFormat類的線程安全問題的方案總結

綜上所示：在解決解決SimpleDateFormat類的線程安全問題的幾種方案中，局部變量法由於線程每次執行格式化時間時，都會創建SimpleDateFormat類的對象，這會導致創建大量的SimpleDateFormat對象，浪費運行空間和消耗服務器的性能，因爲JVM創建和銷燬對象是要耗費性能的。所以，不推薦在高併發要求的生產環境使用。

synchronized鎖方式和Lock鎖方式在處理問題的本質上是一致的，通過加鎖的方式，使同一時刻只能有一個線程執行格式化日期和時間的操作。這種方式雖然減少了SimpleDateFormat對象的創建，但是由於同步鎖的存在，導致性能下降，所以，不推薦在高併發要求的生產環境使用。

ThreadLocal通過保存各個線程的SimpleDateFormat類對象的副本，使每個線程在運行時，各自使用自身綁定的SimpleDateFormat對象，互不干擾，執行性能比較高，推薦在高併發的生產環境使用。

DateTimeFormatter是Java 8中提供的處理日期和時間的類，DateTimeFormatter類本身就是線程安全的，經壓測，DateTimeFormatter類處理日期和時間的性能效果還不錯（後文單獨寫一篇關於高併發下性能壓測的文章）。所以，推薦在高併發場景下的生產環境使用。

joda-time是第三方處理日期和時間的類庫，線程安全，性能經過高併發的考驗，推薦在高併發場景下的生產環境使用。

 

點擊關注，第一時間瞭解華爲雲新鮮技術~

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

前端面試題 - 元素的innerText outerText innerHTML的區別？

前端面試題 - 元素的innerText outerText innerHTML的區別？ innerText和outerText取值都是對象起始和結束標籤內部的文本內容。但是在設置的時候，outerText會把該標籤也替換掉。 inner

原創 2024-04-25 11:51:02

前端面試題 - 在HTML5中DOCTYPE的作用是什麼？標準與兼容模式（混雜模式）各有什麼區別？

前端面試題 - 在HTML5中DOCTYPE的作用是什麼？標準與兼容模式（混雜模式）各有什麼區別？ DOCTYPE（文檔類型聲明）是一種在HTML文檔中使用的標記，用於告訴瀏覽器使用哪個HTML版本解析文檔。它的作用是確保瀏覽器正確地渲染和

原創 2024-04-25 11:51:01

大模型區域落地再加速！百度“文心中國行”西部首站落地成都錦江

​4 月 24 日，“文心中國行”西部地區首站落地成都錦江。成都市錦江區白鷺灣新經濟總部功能區、錦江區投資促進局與百度飛槳攜手合作，打造成都人工智能的新產業、新模式、新業態。來自成都政產學研各界的領導、專家、企業嘉賓，共同探討如何降低 AI

原創 2024-04-25 11:41:53

「實戰應用」如何用圖表控件LightningChart創建2D氣泡圖

LightningChartJS是Web上性能特高的圖表庫，具有出色的執行性能 - 使用高數據速率同時監控數十個數據源。 GPU加速和WebGL渲染確保您的設備的圖形處理器得到有效利用，從而實現高刷新率和流暢的動畫，常用於貿易，工程，航空航

原創 2024-04-25 11:36:06

DevExpress XAF (WinForms UI)賦能醫療管理系統，讓操作更自動化！

DevExpress XAF是一款強大的現代應用程序框架，它採用模塊化設計，開發人員可以選擇內建模塊，也可以自行創建，從而以更快的速度和比開發人員當前更強有力的方式創建應用程序。 獲取DevExpress 新版正式版下載 項目背景 Minh

原創 2024-04-25 11:36:05

大模型Chatbots評估新視角：結合定性與程序方法的實踐探索

隨着人工智能技術的不斷進步，大型語言模型Chatbots已經成爲了人們生活中不可或缺的一部分。無論是在客戶服務、智能助手，還是在線教育、心理諮詢等領域，Chatbots都展現出了巨大的應用潛力。然而，如何有效地評估Chatbots的性能並不

原創 2024-04-25 11:30:02

詳解數倉的向量化執行引擎

本文分享自華爲雲社區《GaussDB(DWS)向量化執行引擎詳解》，作者： yd_212508532。 前言 適用版本：【基線功能】 傳統的行執行引擎大多采用一次一元組的執行模式，這樣在執行過程中CPU大部分時間並沒有用來處理數據，更

原創 2024-04-25 10:33:17

一次故障演練，十分鐘自動搞定?

本文分享自華爲雲社區《應用平臺AppStage運維中心實踐 vol.4 一次故障演練,十分鐘自動搞定?》，作者：yangyang得意。 某業務部涉及200+服務，部署架構複雜，各服務間依賴關係盤根錯節， 每次故障演練都需要耗費大量時間，還容

原創 2024-04-25 10:33:16

柱形圖“變個裝”，跟上時尚步伐！

前言 職場中，日報、週報、月報、年度總結，都離不開圖表的製作，而柱狀圖又是最常用的一種，怎樣的柱狀圖，才能讓領導更容易閱讀，甚至是眼前一亮呢？今天小編就將爲大家介紹一下如何藉助葡萄城公司的嵌入式BI工具——Wyn商業智能軟件修改柱形圖的樣式

原創 2024-04-25 10:23:26

百度安全多篇議題入選Blackhat Asia以硬技術發現“芯”問題

Blackhat Asia 2024於4月中旬在新加坡隆重舉行。此次大會聚集了業界最傑出的信息安全專業人士和研究者，爲參會人員提供了安全領域最新的研究成果和發展趨勢。在本次大會上，百度安全共有三篇技術議題被大會收錄，主要圍繞自動駕駛控制器安

原創 2024-04-25 09:33:19

前端面試題 - 講一講什麼是URL編碼？

前端面試題 - 講一講什麼是URL編碼？ Url編碼通常也被稱爲百分號編碼（Url Encoding），是因爲它的編碼方式非常簡單，使用%百分號加上兩位的字符——代表一個字節的十六進制形式。 例如a在US-ASCII碼中對應的字節是0x61

原創 2024-04-24 23:51:13

前端面試題 - script 標籤中 defer 和 async 的區別？

前端面試題 - script 標籤中 defer 和 async 的區別？   <script> ：會阻礙 HTML 解析，只有下載好並執行完腳本纔會繼續解析 HTML。 <script async> ：解析 HTML 過程中進行腳

原創 2024-04-24 23:51:12

前端面試題 - 說一下原型和原型鏈？

前端面試題 - 說一下原型和原型鏈？ JavaScript 中，萬物皆對象，對象分爲普通對象和函數對象。 所有的函數都是函數對象（typeof f === 'function'），其他都是普通對象（typeof o === 'object'

原創 2024-04-24 23:51:10

前端面試題 - 爲什麼在JS中0.1+0.2!=0.3？以及IEE 754標準

前端面試題 - 爲什麼在JS中0.1+0.2!=0.3？以及IEE 754標準 JavaScript使用Number類型表示數字（整數和浮點數），遵循 IEEE 754 標準 通過64位來表示一個數字。 首先，計算機無法直接對十進制的數字進

原創 2024-04-24 23:51:06

前端面試題 - NodeJS能用ES6模塊嗎？CommonJS 和 ES6模塊的區別是什麼？

前端面試題 - NodeJS能用ES6模塊嗎？CommonJS 和 ES6模塊的區別是什麼？ JS能寫前端web，也能寫NodeJS。 Node.js 後端應用由模塊組成，其模塊系統採用 CommonJS 規範，它並不是 JavaScri

原創 2024-04-24 23:51:06