SimpleDateFormat线程不安全了？这里有5种解决方案

Love The Way You Lie 2022-09-16 13:29 136阅读 0赞

> **摘要：**我们知道SimpleDateFormat是线程不安全，本文会介绍多种解决方案来保证线程安全。

本文分享自华为云社区《[java的SimpleDateFormat线程不安全出问题了，虚竹教你多种解决方案][java_SimpleDateFormat]》，作者：小虚竹 。

## 场景 ##

在java8以前，要格式化日期时间，就需要用到**SimpleDateFormat**。

但我们知道SimpleDateFormat是线程不安全的，处理时要特别小心，要加锁或者不能定义为static，要在方法内new出对象，再进行格式化。很麻烦，而且重复地new出对象，也加大了内存开销。

## SimpleDateFormat线程为什么是线程不安全的呢？ ##

来看看SimpleDateFormat的源码，先看format方法：

// Called from Format after creating a FieldDelegate
        private StringBuffer format(Date date, StringBuffer toAppendTo,
                                    FieldDelegate delegate) {
            // Convert input date to time field list
            calendar.setTime(date);
    		...
        }

问题就出在成员变量**calendar**，如果在使用SimpleDateFormat时，用static定义，那SimpleDateFormat变成了共享变量。那SimpleDateFormat中的**calendar**就可以被多个线程访问到。

SimpleDateFormat的parse方法也是线程不安全的：

public Date parse(String text, ParsePosition pos)
        {
         ...
             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;  
     }

由源码可知，最后是调用\*\*parsedDate = calb.establish(calendar).getTime();\*\*获取返回值。方法的参数是calendar，calendar可以被多个线程访问到，存在线程不安全问题。

我们再来看看\*\*calb.establish(calendar)\*\*的源码

![124cbd9b1a7d26ab5e8e7f8b33cb5cd3.png][]

**calb.establish(calendar)方法先后调用了cal.clear()和cal.set()**,先清理值，再设值。但是这两个操作并不是原子性的，也没有线程安全机制来保证，导致多线程并发时，可能会引起cal的值出现问题了。

## 验证SimpleDateFormat线程不安全 ##

public class SimpleDateFormatDemoTest {
    
    	private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
        public static void main(String[] args) {
        		//1、创建线程池
            ExecutorService pool = Executors.newFixedThreadPool(5);
            //2、为线程池分配任务
            ThreadPoolTest threadPoolTest = new ThreadPoolTest();
            for (int i = 0; i < 10; i++) {
                pool.submit(threadPoolTest);
            }
            //3、关闭线程池
            pool.shutdown();
        }
        static class  ThreadPoolTest implements Runnable{
    
            @Override
            public void run() {
    				String dateString = simpleDateFormat.format(new Date());
    				try {
    					Date parseDate = simpleDateFormat.parse(dateString);
    					String dateString2 = simpleDateFormat.format(parseDate);
    					System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
    				} catch (Exception e) {
    					System.out.println(Thread.currentThread().getName()+" 格式化失败 ");
    				}
            }
        }
    }

![4aaaabebdfcea2d1c19d72ebf7d6daea.png][]

出现了两次false，说明线程是不安全的。而且还抛异常，这个就严重了。

## 解决方案 ##

## 解决方案1：不要定义为static变量，使用局部变量 ##

就是要使用SimpleDateFormat对象进行format或parse时，再定义为局部变量。就能保证线程安全。

public class SimpleDateFormatDemoTest1 {
    
        public static void main(String[] args) {
        		//1、创建线程池
            ExecutorService pool = Executors.newFixedThreadPool(5);
            //2、为线程池分配任务
            ThreadPoolTest threadPoolTest = new ThreadPoolTest();
            for (int i = 0; i < 10; i++) {
                pool.submit(threadPoolTest);
            }
            //3、关闭线程池
            pool.shutdown();
        }
        static class  ThreadPoolTest implements Runnable{
    
    		@Override
    		public void run() {
    			SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    			String dateString = simpleDateFormat.format(new Date());
    			try {
    				Date parseDate = simpleDateFormat.parse(dateString);
    				String dateString2 = simpleDateFormat.format(parseDate);
    				System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
    			} catch (Exception e) {
    				System.out.println(Thread.currentThread().getName()+" 格式化失败 ");
    			}
    		}
        }
    }

![676d3f94e149a4c65c750c41cc21a0e0.png][]

由图可知，已经保证了线程安全，**但这种方案不建议在高并发场景下使用**，因为会创建大量的SimpleDateFormat对象，影响性能。

## 解决方案2：加锁：synchronized锁和Lock锁 ##

### 加synchronized锁 ###

SimpleDateFormat对象还是定义为全局变量，然后需要调用SimpleDateFormat进行格式化时间时，再用synchronized保证线程安全。

public class SimpleDateFormatDemoTest2 {
    
    	private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
        public static void main(String[] args) {
        		//1、创建线程池
            ExecutorService pool = Executors.newFixedThreadPool(5);
            //2、为线程池分配任务
            ThreadPoolTest threadPoolTest = new ThreadPoolTest();
            for (int i = 0; i < 10; i++) {
                pool.submit(threadPoolTest);
            }
            //3、关闭线程池
            pool.shutdown();
        }
    
        static class  ThreadPoolTest implements Runnable{
    
    		@Override
    		public void run() {
    			try {
    				synchronized (simpleDateFormat){
    					String dateString = simpleDateFormat.format(new Date());
    					Date parseDate = simpleDateFormat.parse(dateString);
    					String dateString2 = simpleDateFormat.format(parseDate);
    					System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
    				}
    			} catch (Exception e) {
    				System.out.println(Thread.currentThread().getName()+" 格式化失败 ");
    			}
    		}
        }
    }

![d674d7be7a37d1224d5fa9becc8db111.png][]

如图所示，线程是安全的。定义了全局变量SimpleDateFormat，减少了创建大量SimpleDateFormat对象的损耗。但是使用synchronized锁，  
同一时刻只有一个线程能执行锁住的代码块，在高并发的情况下会影响性能。**但这种方案不建议在高并发场景下使用**

### 加Lock锁 ###

加Lock锁和synchronized锁原理是一样的，都是使用锁机制保证线程的安全。

public class SimpleDateFormatDemoTest3 {
    
    	private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	private static Lock lock = new ReentrantLock();
        public static void main(String[] args) {
        		//1、创建线程池
            ExecutorService pool = Executors.newFixedThreadPool(5);
            //2、为线程池分配任务
            ThreadPoolTest threadPoolTest = new ThreadPoolTest();
            for (int i = 0; i < 10; i++) {
                pool.submit(threadPoolTest);
            }
            //3、关闭线程池
            pool.shutdown();
        }
    
        static class  ThreadPoolTest implements Runnable{
    
    		@Override
    		public void run() {
    			try {
    				lock.lock();
    					String dateString = simpleDateFormat.format(new Date());
    					Date parseDate = simpleDateFormat.parse(dateString);
    					String dateString2 = simpleDateFormat.format(parseDate);
    					System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
    			} catch (Exception e) {
    				System.out.println(Thread.currentThread().getName()+" 格式化失败 ");
    			}finally {
    				lock.unlock();
    			}
    		}
        }
    }

![f23cc322b937b4c82a6459a16bdfa48c.png][]

由结果可知，加Lock锁也能保证线程安全。要注意的是，最后一定要释放锁，代码里在**finally里增加了lock.unlock();**，保证释放锁。

在高并发的情况下会影响性能。**这种方案不建议在高并发场景下使用**

## 解决方案3：使用ThreadLocal方式 ##

使用ThreadLocal保证每一个线程有SimpleDateFormat对象副本。这样就能保证线程的安全。

public class SimpleDateFormatDemoTest4 {
    
    	private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
    		@Override
    		protected DateFormat initialValue() {
    			return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		}
    	};
        public static void main(String[] args) {
        		//1、创建线程池
            ExecutorService pool = Executors.newFixedThreadPool(5);
            //2、为线程池分配任务
            ThreadPoolTest threadPoolTest = new ThreadPoolTest();
            for (int i = 0; i < 10; i++) {
                pool.submit(threadPoolTest);
            }
            //3、关闭线程池
            pool.shutdown();
        }
    
        static class  ThreadPoolTest implements Runnable{
    
    		@Override
    		public void run() {
    			try {
    					String dateString = threadLocal.get().format(new Date());
    					Date parseDate = threadLocal.get().parse(dateString);
    					String dateString2 = threadLocal.get().format(parseDate);
    					System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
    			} catch (Exception e) {
    				System.out.println(Thread.currentThread().getName()+" 格式化失败 ");
    			}finally {
    				//避免内存泄漏，使用完threadLocal后要调用remove方法清除数据
    				threadLocal.remove();
    			}
    		}
        }
    }

![d8f227804e33a2bdfc9e8e760e2db7ed.png][]

使用ThreadLocal能保证线程安全，且效率也是挺高的。**适合高并发场景使用**。

## 解决方案4：使用DateTimeFormatter代替SimpleDateFormat ##

使用DateTimeFormatter代替SimpleDateFormat（DateTimeFormatter是线程安全的，java 8+支持）

DateTimeFormatter介绍 传送门：[万字博文教你搞懂java源码的日期和时间相关用法][java]

public class DateTimeFormatterDemoTest5 {
    	private static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    
    	public static void main(String[] args) {
    		//1、创建线程池
    		ExecutorService pool = Executors.newFixedThreadPool(5);
    		//2、为线程池分配任务
    		ThreadPoolTest threadPoolTest = new ThreadPoolTest();
    		for (int i = 0; i < 10; i++) {
    			pool.submit(threadPoolTest);
    		}
    		//3、关闭线程池
    		pool.shutdown();
    	}
    	static class  ThreadPoolTest implements Runnable{
    
    		@Override
    		public void run() {
    			try {
    				String dateString = dateTimeFormatter.format(LocalDateTime.now());
    				TemporalAccessor temporalAccessor = dateTimeFormatter.parse(dateString);
    				String dateString2 = dateTimeFormatter.format(temporalAccessor);
    				System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
    			} catch (Exception e) {
    				e.printStackTrace();
    				System.out.println(Thread.currentThread().getName()+" 格式化失败 ");
    			}
    		}
    	}
    }

![c7018fa81470050d7e776457484e04bc.png][]

使用DateTimeFormatter能保证线程安全，且效率也是挺高的。**适合高并发场景使用**。

## 解决方案5：使用FastDateFormat 替换SimpleDateFormat ##

使用FastDateFormat 替换SimpleDateFormat（FastDateFormat 是线程安全的，Apache Commons Lang包支持，不受限于java版本）

public class FastDateFormatDemo6 {
    	private static FastDateFormat fastDateFormat = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");
    
    	public static void main(String[] args) {
    		//1、创建线程池
    		ExecutorService pool = Executors.newFixedThreadPool(5);
    		//2、为线程池分配任务
    		ThreadPoolTest threadPoolTest = new ThreadPoolTest();
    		for (int i = 0; i < 10; i++) {
    			pool.submit(threadPoolTest);
    		}
    		//3、关闭线程池
    		pool.shutdown();
    	}
    	static class  ThreadPoolTest implements Runnable{
    
    		@Override
    		public void run() {
    			try {
    				String dateString = fastDateFormat.format(new Date());
    				Date parseDate =  fastDateFormat.parse(dateString);
    				String dateString2 = fastDateFormat.format(parseDate);
    				System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
    			} catch (Exception e) {
    				e.printStackTrace();
    				System.out.println(Thread.currentThread().getName()+" 格式化失败 ");
    			}
    		}
    	}
    }

使用FastDateFormat能保证线程安全，且效率也是挺高的。**适合高并发场景使用**。

### FastDateFormat源码分析 ###

Apache Commons Lang 3.5
    //FastDateFormat
    @Override
    public String format(final Date date) {
       return printer.format(date);
    }
    
    	@Override
    	public String format(final Date date) {
    		final Calendar c = Calendar.getInstance(timeZone, locale);
    		c.setTime(date);
    		return applyRulesToString(c);
    	}

源码中 Calender 是在 format 方法里创建的，肯定不会出现 setTime 的线程安全问题。这样线程安全疑惑解决了。那还有性能问题要考虑？

我们来看下FastDateFormat是怎么获取的

FastDateFormat.getInstance();
    FastDateFormat.getInstance(CHINESE_DATE_TIME_PATTERN);

看下对应的源码

/**
     * 获得 FastDateFormat实例，使用默认格式和地区
     *
     * @return FastDateFormat
     */
    public static FastDateFormat getInstance() {
       return CACHE.getInstance();
    }
    
    /**
     * 获得 FastDateFormat 实例，使用默认地区<br>
     * 支持缓存
     *
     * @param pattern 使用{@link java.text.SimpleDateFormat} 相同的日期格式
     * @return FastDateFormat
     * @throws IllegalArgumentException 日期格式问题
     */
    public static FastDateFormat getInstance(final String pattern) {
       return CACHE.getInstance(pattern, null, null);
    }

这里有用到一个CACHE，看来用了缓存，往下看

private static final FormatCache<FastDateFormat> CACHE = new FormatCache<FastDateFormat>(){
       @Override
       protected FastDateFormat createInstance(final String pattern, final TimeZone timeZone, final Locale locale) {
          return new FastDateFormat(pattern, timeZone, locale);
       }
    };
    
    //
    abstract class FormatCache<F extends Format> {
        ...
        private final ConcurrentMap<Tuple, F> cInstanceCache = new ConcurrentHashMap<>(7);
    
    	private static final ConcurrentMap<Tuple, String> C_DATE_TIME_INSTANCE_CACHE = new ConcurrentHashMap<>(7);
        ...
    }

![a53d0c81a2e74e511920abd89d99524c.png][]

在getInstance 方法中加了ConcurrentMap 做缓存，提高了性能。且我们知道ConcurrentMap 也是线程安全的。

### 实践 ###

/**
     * 年月格式 {@link FastDateFormat}：yyyy-MM
     */
    public static final FastDateFormat NORM_MONTH_FORMAT = FastDateFormat.getInstance(NORM_MONTH_PATTERN);

![3562f2eb514faf6e31f1b0e96998bc62.png][]

//FastDateFormat
    public static FastDateFormat getInstance(final String pattern) {
       return CACHE.getInstance(pattern, null, null);
    }

![4739e10449c1b541a94f3646ca3f420e.png][]

![2077f07746b69ec11f5a2447fc1464d3.png][]

如图可证，是使用了ConcurrentMap 做缓存。且key值是格式，时区和locale（语境）三者都相同为相同的key。

## 结论 ##

1、不要定义为static变量，使用局部变量

2、加锁：synchronized锁和Lock锁

3、使用ThreadLocal方式

4、使用DateTimeFormatter代替SimpleDateFormat（DateTimeFormatter是线程安全的，java 8+支持）

5、使用FastDateFormat 替换SimpleDateFormat（FastDateFormat 是线程安全的，Apache Commons Lang包支持，java8之前推荐此用法）

**[点击关注，第一时间了解华为云新鲜技术~][Link 1]**

[java_SimpleDateFormat]: https://link.zhihu.com/?target=https%3A//bbs.huaweicloud.com/blogs/305813%3Futm_source%3Dzhihu%26utm_medium%3Dbbs-ex%26utm_campaign%3Dother%26utm_content%3Dcontent
[124cbd9b1a7d26ab5e8e7f8b33cb5cd3.png]: /images/20220828/61cab50ce0634fe0a4306a067b906870.png
[4aaaabebdfcea2d1c19d72ebf7d6daea.png]: /images/20220828/b90066a7364c42afb2bd6d9567b1a480.png
[676d3f94e149a4c65c750c41cc21a0e0.png]: /images/20220828/8b96da8e6ae346d0ba0ac35588cc4d12.png
[d674d7be7a37d1224d5fa9becc8db111.png]: /images/20220828/a52d7ee2db014b07a0370022030060dd.png
[f23cc322b937b4c82a6459a16bdfa48c.png]: /images/20220828/dd6dcd5995bf4cc69af6cc8f7e0330a5.png
[d8f227804e33a2bdfc9e8e760e2db7ed.png]: /images/20220828/88a6bef85c694f529005df62f8b6c568.png
[java]: https://xiaoxuzhu.blog.csdn.net/article/details/118947669
[c7018fa81470050d7e776457484e04bc.png]: /images/20220828/d445a63065b342ecb4d65885ee9f57f7.png
[a53d0c81a2e74e511920abd89d99524c.png]: /images/20220828/5df1baa60af547eeb788ff2a8dbf86e0.png
[3562f2eb514faf6e31f1b0e96998bc62.png]: /images/20220828/3e9c78552a7946a38907988992b90bde.png
[4739e10449c1b541a94f3646ca3f420e.png]: /images/20220828/1153c5a5c5ee4230a33f300a083bd1d0.png
[2077f07746b69ec11f5a2447fc1464d3.png]: /images/20220828/7abf8f41b1554922b2531a79726bd1f3.png
[Link 1]: https://link.zhihu.com/?target=https%3A//bbs.huaweicloud.com/blogs%3Futm_source%3Dzhihu%26utm_medium%3Dbbs-ex%26utm_campaign%3Dother%26utm_content%3Dcontent