日常開發中，經常會遇見對日期進行格式化，比如將日期格式化為"剛剛"、"幾分鐘前"、"昨天"、"幾天前"、"YYYY-MM-DD hh:mm:ss"等等，為此基于day.js封裝了一個小函數，代碼如下

//utils.js
import dayjs from 'dayjs'

//對傳入的日期格式無限制可以是YYYY-MM-DD hh:mm:ss也可以是時間戳
const formatDate = (t=Date.now()) => {
    if(!t) return ''
    // 獲取當前日期
    const now = dayjs();
    
    // 模擬一個過去的日期
    const pastDate = dayjs(t);
    
    // 計算時間差/分
    const diff = now.diff(pastDate, 'minute');

    // 計算時間差/時
    const diffHours = dayjs().diff(pastDate, 'hour');
    
    // 計算時間差/天
    const diffDays = dayjs().diff(pastDate, 'day');
    
    let txt=''
    if (diff < 2) {
        txt=`剛剛`
    } else if (diff < 60) {
        txt=`${diff} 分鐘前`
    } else if (diffHours<24) {
        txt=`${diffHours} 小時前`
    } else if (now.diff(pastDate, 'day') === 1) {
        txt=`昨天`
    } else if (diffDays <5) {
        txt=`${diffDays} 天前`
    } else {
        txt = pastDate.format('YYYY-MM-DD');
    }
    console.log('/day.js [88]--1','txt',txt);
    return txt
  
}

測試代碼

impleDateFormat 是 Java提供的一個格式化和解析日期的工具類，日常開發中應該經常會用到，但是它是線程不安全的。

多線程公用一個 SimpleDateFormat實例 對日期進行解析或者格式化會導致程序出錯，本節就討論下它為何是線程不安全的，以及如何避免。

一、SimpleDateFormat 線程不安全演示和分析

1.1、問題復現

public class TestSimpleDateFormat {
 //(1)創建單例實例
 static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 public static void main(String[] args) {
  //(2)創建多個線程，并啟動
  for (int i = 0; i <10 ; ++i) {
   Thread thread = new Thread(new Runnable() {
    public void run() {
     try {//(3)使用單例日期實例解析文本
      System.out.println(sdf.parse("2017-12-13 15:17:27"));
     } catch (ParseException e) {
      e.printStackTrace();
     }
    }
   });
   thread.start();//(4)啟動線程
  }
 }

代碼（1）創建了SimpleDateFormat的一個實例；

代碼（2）創建10個線程，每個線程都共用同一個sdf對象對文本日期進行解析，多運行幾次就會拋出java.lang.NumberFormatException異常，加大線程的個數有利于該問題復現。

1.2、問題分析

為了便于分析首先奉上SimpleDateFormat的類圖結構：

SimpleDateFormat 類結構圖

1. 可知每個SimpleDateFormat實例里面有一個Calendar對象。
2. 從后面會知道其實 SimpleDateFormat 之所以是線程不安全的就是因為Calendar是線程不安全的。
3. SimpleDateFormat 之所以是線程不安全的是因為其中存放日期數據的變量都是線程不安全的，比如里面的fields，time等。

下面從代碼層面看下parse方法做了什么事情：

#### parse() 方法

public Date parse(String text, ParsePosition pos)
{
 //(1)解析日期字符串放入CalendarBuilder的實例calb中
 .....
  Date parsedDate;
 try {//（2）使用calb中解析好的日期數據設置calendar
  parsedDate = calb.establish(calendar).getTime();
  ...
  }
 catch (IllegalArgumentException e) {
  ...
   return null;
 }
 return parsedDate;
}

## establish() 方法

Calendar establish(Calendar cal) {
   ...
   //（3）重置日期對象cal的屬性值
   cal.clear();
   //(4) 使用calb中中屬性設置cal
   ...
   //(5)返回設置好的cal對象
   return cal;
}

• 代碼（1）主要的作用是解析字符串日期并把解析好的數據放入了 CalendarBuilder的實例calb中，CalendarBuilder是一個建造者模式，用來存放后面需要的數據。
• 代碼（3）重置Calendar對象里面的屬性值，如下代碼：

public final void clear() {
    for (int i = 0; i < fields.length; ) {
        stamp[i] = fields[i] = 0; // UNSET == 0
        isSet[i++] = false;
    }
    areAllFieldsSet = areFieldsSet = false;
    isTimeSet = false;
}

• 代碼（4）使用calb中解析好的日期數據設置cal對象
• 代碼（5） 返回設置好的cal對象

從上面步驟可知步驟（3）（4）（5）操作不是原子性操作。

當多個線程調用parse方法時候比如線程A執行了步驟（3）（4）也就是設置好了cal對象，在執行步驟（5）前線程B執行了步驟（3）清空了cal對象，由于多個線程使用的是一個cal對象，所以線程A執行步驟（5）返回的就可能是被線程B清空后的對象，當然也有可能線程B執行了步驟（4）被線程B修改后的cal對象。從而導致程序錯誤。

二、SimpleDateFormat 線程不安全的解決方式

方式一：每個線程創建一個 SimpleDateFormat實例

每次使用時候new一個SimpleDateFormat的實例，這樣可以保證每個實例使用自己的Calendar實例,但是每次使用都需要new一個對象，并且使用后由于沒有其它引用，就會需要被回收，開銷會很大。

方式二：synchronized 同步鎖

究其原因是因為多線程下步驟（3）（4）（5）三個步驟不是一個原子性操作，那么容易想到的是對其進行同步，讓（3）（4）（5）成為原子操作，可以使用synchronized進行同步。

public class TestSimpleDateFormat {
 // (1)創建單例實例
 static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 public static void main(String[] args) {
  // (2)創建多個線程，并啟動
  for (int i = 0; i < 10; ++i) {
   Thread thread = new Thread(new Runnable() {
    public void run() {
     try {// (3)使用單例日期實例解析文本
      synchronized (sdf) {
       System.out.println(sdf.parse("2017-12-13 15:17:27"));
      }
     } catch (ParseException e) {
      e.printStackTrace();
     }
    }
   });
   thread.start();// (4)啟動線程
  }
 }
}

使用同步意味著多個線程要競爭鎖，在高并發場景下會導致系統響應性能下降。

方式三：使用ThreadLocal （推薦）

每個線程只需要使用一個 SimpleDateFormat 實例相比第一種方式大大節省了對象的創建銷毀開銷，并且不需要對多個線程直接進行同步。

public class TestSimpleDateFormat2 {
 // (1)創建threadlocal實例
 static ThreadLocal<DateFormat> safeSdf = new ThreadLocal<DateFormat>(){
  @Override 
  protected SimpleDateFormat initialValue(){
   return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  }
 };
 
 public static void main(String[] args) {
  // (2)創建多個線程，并啟動
  for (int i = 0; i < 10; ++i) {
   Thread thread = new Thread(new Runnable() {
    public void run() {
     try {// (3)使用單例日期實例解析文本
       System.out.println(safeSdf.get().parse("2017-12-13 15:17:27"));
     } catch (ParseException e) {
      e.printStackTrace();
     }
    }
   });
   thread.start();// (4)啟動線程
  }
 }
}

• 代碼（1）創建了一個線程安全的SimpleDateFormat實例。
• 步驟（3）在使用的時候首先使用get()方法獲取當前線程下SimpleDateFormat的實例，在第一次調用ThreadLocal的get()方法時會觸發其initialValue方法用來創建當前線程所需要的SimpleDateFormat對象。

三、問題思考

3.1、采用new 對象作為局部變量的局限性

如果線程調用多個類的其他方法，并且其他地方需要日期格式化，在線程代碼中new的對象，其他地方不一定會訪問得到。如果想復用的話，

1. 在方法之間需要將其作為方法的參數進行傳遞。
2. 方法間不傳遞的話，需要new 多個實例。

3.2、使用 ThreadLocal 的優點

【ThreadLocal 中設置的變量是線程本身變量池的值，所以只要是同一線程，在執行任何類的代碼的時候都可以獲取得到；只需要創建一個實例】。

就像在使用pagehelper設置分頁參數時，它就是放在ThreadLocal中的，所以后續的查詢調用其他類的其他方法，需要這幾個值都是直接從線程本身取這個值。

不過ThreadLocal使用完其中的值后最好remove下，不然一些情況會造成內存泄露。

原文 https://cn-blogs.cn/archives/10783.html