2. 程式人生 > 其它 >SimpleDateFormat類的安全問題，這6個方案總有一個適合你

SimpleDateFormat類的安全問題，這6個方案總有一個適合你

阿新 • • 發佈：2022-04-13
摘要：你使用的SimpleDateFormat類還安全嗎？為什麼說SimpleDateFormat類不是執行緒安全的？帶著問題從本文中尋求答案。

本文分享自華為雲社群《【高併發】SimpleDateFormat類的執行緒安全問題和解決方案（附6種解決方案）》，作者： 冰 河。

首先問下大家：你使用的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類的執行緒安全問題

解決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是第三方處理日期和時間的類庫，執行緒安全，效能經過高併發的考驗，推薦在高併發場景下的生產環境使用。

 

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

相關推薦

SimpleDateFormat類的安全問題，這6個方案總有一個適合你

摘要：你使用的SimpleDateFormat類還安全嗎？為什麼說SimpleDateFormat類不是執行緒安全的？帶著問題從本文中尋求答案。

【Android 資料庫框架總結，總有一個適合你！】

https://blog.csdn.net/da_caoyuan/article/details/61414626?utm_source=distribute.pc_relevant.none-task

springboot圖書商城專案_13 個最火的 SpringBoot 實戰 開源專案推薦！總有一個適合你！...

技術標籤：springboot圖書商城專案springboot許可權控制springboot許可權管理springboot使用者管理系統springboot專案實戰vue springboot部署

Java中處理正則表示式的工具類——總有一個適合你

import java.util.ArrayList; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern;

這6個電腦操作技巧，會讓你愛上Win10系統

要說電腦系統哪個版本最好用，大家都異口同聲的說是Win7，也許你只是用習慣了。

應對航空安全擔憂，AT＆T 與 Verizon 同意暫時限制 5G 服務，為期 6 個月

11 月 25 日訊息，據《華爾街日報》報道，因為聯邦監管機構正在調查 5G 訊號對飛機感測器的影響，AT＆T 與 Verizon同意對 5G 無線服務做出限制，為期六個月。在致聯邦通訊委員會（FCC）的一封信中，AT＆T 與 Verizo

設計師一定要知道這6個，免費、可商用的圖片素材網站

​ 在日常生活中，經常需要用到各種圖片，做設計需要用到背景圖片、寫文章需要用到插圖，平時小到發朋友圈都需要用到圖片來點綴。

Java多執行緒環境下SimpleDateFormat類安全轉換

一、SimpleDateFormat類 package state; import java.text.ParseException; import java.text.SimpleDateFormat;

學習 Python，這 22 個包怎能不掌握？

如今全球各個行業內 Python 的使用狀況怎麼樣呢？ 很多人學習python，不知道從何學起。很多人學習python，掌握了基本語法過後，不知道在哪裡尋找案例上手。很多已經做案例的人，卻不知道如何去學習更加高深的知識。那

用過 mongodb 吧， 這三個大坑踩過嗎？

一：背景 1. 講故事 前段時間有位朋友在微信群問，在向 mongodb 中插入的時間為啥取出來的時候少了 8 個小時，8 在時間處理上是一個非常敏感的數字，又吉利又是一個普適的話題，後來我想想初次使用 mongodb 的朋友一

通過利用cpon的值借用 mongodb過二妙吧， 這易個大坑路過碼？

一：背景 1. 講故事 前段時間有位朋友在微信群問，在向 mongodb 中插入的時間為啥取出來的時候少了 8 個小時，8 在時間處理上是一個非常敏感的數字，又吉利又是一個普適的話題，後來我想想初次使用 mongodb 的朋友一

JavaScript 中，這幾個操作物件的方法很實用

本文整理了 6 個比較實用的操作物件的方法。 Object.create() 以引數為原型，建立一個新物件例項。

【Spring註解驅動開發】AOP核心類解析，這是最全的一篇了！！

寫在前面 昨天二狗子讓我給他講@EnableAspectJAutoProxy註解，講到AnnotationAwareAspectJAutoProxyCreator類的原始碼時，二狗子消化不了了。這不，今天又來讓我給他講講AOP的核心類。那我們就開始吧！

Linux網路安全，這本搞定了！

1991年，芬蘭赫爾辛基大學的學生林納斯·本納第克特·託瓦茲（Linus Benedict Torvalds）在使用一個叫作Minix的作業系統。Minix（名稱來源於“mini-Unix”）是設計用於教學的一個類Unix的作

微信記錄如何永久刪除，這幾個有效的刪除方法你嘗試過嗎？

文章目錄方法一：微信自帶清理功能方法二：恢復出廠設定方法三：恢復大師

想要寫出不那麼差的程式碼，這4個IDEA外掛可一定要知道！

在寫程式碼的時候，有幾個 IDEA 外掛對於我規範程式碼以及更高效地完成編碼工作有奇效。

第 3 次讀 Effective Java，這 58 個技巧最值！

《Effective Java》Java名著，必讀。如果能嚴格遵從本文的原則，以編寫API的質量來苛求自己的程式碼，會大大提升編碼素質。

我去，這兩個小技巧，讓我的SQL語句不僅躲了坑，還提升了 1000 倍（半分鐘乾貨系列）

本次來講解與 SQL 查詢有關的兩個小知識點，掌握這些知識點，能夠讓你避免踩坑以及提高查詢效率。

Win10 商店莫名其妙斷連怎麼辦，這幾個實用小招數教給你

雖然 Win10 的應用商店並不如 Android 或者 iOS 的繁華，也少有大型軟體進駐，但很多小工具和系統元件還是需要依賴 Win10 商店釋出和更新的。

2021 年高考拉開大幕，這幾個謠言可信不得

6 月 7 日訊息 今日，2021 年高考拉開大幕。每年高考前夕，網上總會有些不良機構或不法分子動起“歪腦筋”，借高考散佈虛假資訊，誤導考生和公眾，甚至實施詐騙。