摘要：我們就一起看下在高併發下SimpleDateFormat類為何會出現安全問題，以及如何解決SimpleDateFormat類的安全問題。
本文分享自華為雲社群《SimpleDateFormat類的執行緒安全問題和解決方案》，作者： 冰 河。
首先問下大家：你使用的SimpleDateFormat類還安全嗎？為什麼說SimpleDateFormat類不是執行緒安全的？帶著問題從本文中尋求答案。
提起SimpleDateFormat類，想必做過Java開發的童鞋都不會感到陌生。沒錯，它就是Java中提供的日期時間的轉化類。這裡，為什麼說SimpleDateFormat類有執行緒安全問題呢？有些小夥伴可能會提出疑問：我們生產環境上一直在使用SimpleDateFormat類來解析和格式化日期和時間型別的資料，一直都沒有問題啊！我的回答是：沒錯，那是因為你們的系統達不到SimpleDateFormat類出現問題的併發量，也就是說你們的系統沒啥負載！
接下來，我們就一起看下在高併發下SimpleDateFormat類為何會出現安全問題，以及如何解決SimpleDateFormat類的安全問題。
重現SimpleDateFormat類的執行緒安全問題
為了重現SimpleDateFormat類的執行緒安全問題，一種比較簡單的方式就是使用執行緒池結合Java併發包中的CountDownLatch類和Semaphore類來重現執行緒安全問題。
有關CountDownLatch類和Semaphore類的具體用法和底層原理與原始碼解析在【高併發專題】後文會深度分析。這裡，大家只需要知道CountDownLatch類可以使一個執行緒等待其他執行緒各自執行完畢後再執行。而Semaphore類可以理解為一個計數訊號量，必須由獲取它的執行緒釋放，經常用來限制訪問某些資源的執行緒數量，例如限流等。
好了，先來看下重現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 測試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類中，首先定義了兩個常量，一個是程式執行的總次數，一個是同時執行的執行緒數量。程式中結合線程池和CountDownLatch類與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
說明，在高併發下使用SimpleDateFormat類格式化日期時丟擲了異常，SimpleDateFormat類不是執行緒安全的！！！
接下來，我們就看下，SimpleDateFormat類為何不是執行緒安全的。
SimpleDateFormat類為何不是執行緒安全的？
那麼，接下來，我們就一起來看看真正引起SimpleDateFormat類執行緒不安全的根本原因。
通過檢視SimpleDateFormat類的原始碼，我們得知：SimpleDateFormat是繼承自DateFormat類，DateFormat類中維護了一個全域性的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類在高併發場景下的執行緒安全問題可以有多種方式，這裡，就列舉幾個常用的方式供參考。
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是第三方處理日期和時間的類庫，執行緒安全，效能經過高併發的考驗，推薦在高併發場景下的生產環境使用。