解密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類的線程安全問題

解決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類的線程安全問題和六種解決方案！

重制SimpleDateFormat類的線程安全問題

SimpleDateFormat類為何不是線程安全的？

解決SimpleDateFormat類的線程安全問題

1.局部變量法

2.synchronized鎖方式

3.Lock鎖方式

4.ThreadLocal方式

5.DateTimeFormatter方式

6.joda-time方式

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

繼續閱讀

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

maven No compiler is provided in this environment. Perhaps you are running on a JRE rather than a J

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

Opendaylight課堂之深度剖析toaster（一）