文档备案控制台登录立即注册
首页文章问答视频活动下载资源开发者计划团队号镜像站
发布

SimpleDateFormat类是否线程安全

风之馨技术录
风之馨技术录
云原生
火山方舟向量数据库大模型

SimpleDateFormat是java中提供的日期时间转换类,你觉得它有线程安全吗,工作几年的开发工程师估计也觉得没啥问题，之所以没问题主要是系统达不到它出现问题的并发量。接下来我们使用java并发包中的CountDownLatch类和Semaphore类来重新线程安全。 Count D own Latch可以是一个线程等待其他线程各自执行完毕后再继续执行。 S em

apho re是一个计数信号量,必须由获取它的线程释放,经常用来限制访问某些资源的线程数量,如限流等。

重新SimpleDateFormat线程安全案例

  
package com.lmf.demo.entity;  
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;  
public class TestSimpleDateFormat {  
 //执行总次数  
 private static final int EXECUTE_COUNT=100;  
    //运行的线程数  
    private static final int THREAD_COUNT=10;  
    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.submit(()->{  
 try {  
 semaphore.acquire();  
 try{  
 simpleDateFormat.parse("2021-12-13");  
 } catch (NumberFormatException e){  
 System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");  
 e.printStackTrace();  
 System.exit(1);  
 } catch (ParseException 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("所有线程格式化日期成功");  
 }  
}

picture.image

我们定义了俩个常量EXECUTE_COUNT(执行数量)和THREAD_COUNT(线程个数),并且结合线程池的Semaphore类和CountDownLatch类来模拟高并发的业务场景。如果程序正确运行会打印"所有线程格式化日期成功",但是程序抛出了异常,说明SimpleDateFormat不是线程安全的。

带着疑问我们跟进一下SimpleDateFormat源码，看为什么它线程不安全

picture.image

它继承DateFormat类,我们看下DateFormat类源码，它维护一个全局的Calendar变量,它可以用来格式化或解析日期时间。接下来我们看parse方法

picture.image

  
public Date parse(String text, ParsePosition pos)  
{  
        //省略部分代码,bu'ying  
 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;  
 }

解析最后的返回值是通过调用calb.establish(calendar).getTime(),这个方法的参数正是全局变量 Calendar对象。接下来看看 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;  
 }

先后调用 cal.clear()和cal.set()方法,先清除cal对象中设置的值,再重新设置新的值。由于Calendar内部没有线程安全机制,并且俩个操作也不是原子性的,所以当多个线程同时操作一个SimpleDateFormat时就会引起cal值的混乱。所以SimpleDateFormat类不是线程安全的根本原因是：DateFormat类中的Calendar对象被多线程共享，而Calendar对象本身不支持线程安全。

解决方案

1.局部变量法,但是会创建大量的SimpleDateFormat,影响程序的性能

  
package com.lmf.demo.entity;  
  
  
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;  
  
public class TestSimpleDateFormat {  
 //执行总次数  
 private static final int EXECUTE_COUNT=100;  
 //运行的线程数量  
 private static final int THREAD_COUNT=10;  
  
 /*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.submit(()->{  
 try {  
 semaphore.acquire();  
 try{  
 SimpleDateFormat simpleDateFormat=new SimpleDateFormat("YYYY-MM-dd");  
 simpleDateFormat.parse("2021-12-13");  
 } catch (NumberFormatException e){  
 System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");  
 e.printStackTrace();  
 System.exit(1);  
 } catch (ParseException 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("所有线程格式化日期成功");  
 }  
}

picture.image

2.synchronized锁方式,能解决线程安全问题，但是同一个时刻只能有一个线程执行方法,会影响程序的性能。

  
package com.lmf.demo.entity;  
  
  
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;  
  
public class TestSimpleDateFormat {  
 //执行总次数  
 private static final int EXECUTE_COUNT=300;  
 //运行的线程数量  
    private static final int THREAD_COUNT=30;  
    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.submit(()->{  
 try {  
 semaphore.acquire();  
 try{  
 synchronized (simpleDateFormat){  
 simpleDateFormat.parse("2021-12-13");  
 }  
 } catch (NumberFormatException e){  
 System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");  
 e.printStackTrace();  
 System.exit(1);  
 } catch (ParseException 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("所有线程格式化日期成功");  
 }  
}

3.Lock锁方式和synchronized锁实现原理一样,都是在高并发下通过jvm的锁机制来保证程序的线程安全。

  
package com.lmf.demo.entity;  
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;  
public class TestSimpleDateFormat {  
 //执行总次数  
 private static final int EXECUTE_COUNT=300;  
 //运行的线程数量  
    private static final int THREAD_COUNT=30;  
    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.submit(()->{  
 try {  
 semaphore.acquire();  
 try{  
 lock.lock();  
 simpleDateFormat.parse("2021-12-13");  
 } catch (NumberFormatException e){  
 System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");  
 e.printStackTrace();  
 System.exit(1);  
 } catch (ParseException 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("所有线程格式化日期成功");  
 }  
}

4.ThreadLocal存储每个线程拥有的SimpleDateFormat对象的副本,能够有效的避免多线程造成的线程安全问题。运行效率比较高，高并发业务场景可以使用此方法。

  
package com.lmf.demo.entity;  
  
  
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;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
public class TestSimpleDateFormat {  
 //执行总次数  
 private static final int EXECUTE_COUNT=300;  
 //运行的线程数量  
    private static final int THREAD_COUNT=30;  
    /*private static SimpleDateFormat simpleDateFormat=new SimpleDateFormat("YYYY-MM-dd");*/  
 private static ThreadLocal<DateFormat> threadLocal= ThreadLocal.withInitial(() -> 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.submit(()->{  
 try {  
 semaphore.acquire();  
 try{  
 /* lock.lock();*/  
 threadLocal.get().parse("2021-12-13");  
 } catch (NumberFormatException e){  
 System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");  
 e.printStackTrace();  
 System.exit(1);  
 } catch (ParseException 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("所有线程格式化日期成功");  
 }  
}

5.DateTimeFormatter是java 8提供的新的日期时间api的类,它是线程安全的，可以在高并发场景下使用。

  
package com.lmf.demo.entity;  
import java.text.DateFormat;  
import java.text.ParseException;  
import java.text.SimpleDateFormat;  
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;  
public class TestSimpleDateFormat {  
 //执行总次数  
 private static final int EXECUTE_COUNT=300;  
 //运行的线程数量  
    private static final int THREAD_COUNT=30;  
    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.submit(()->{  
 try {  
 semaphore.acquire();  
 try{  
 formatter.parse("2021-12-13");  
 } 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("所有线程格式化日期成功");  
 }  
}

6.jodb-time是第三方处理日期时间格式化的类库,它是线程安全的，效率也很高,推荐再高并发场景使用。

  
 <dependency>  
 <groupId>joda-time</groupId>  
 <artifactId>joda-time</artifactId>  
 <version>2.9.9</version>  
 </dependency>

代码示例:

  
package com.lmf.demo.entity;  
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;  
public class TestSimpleDateFormat {  
 //执行总次数  
 private static final int EXECUTE_COUNT=300;  
 //运行的线程数量  
 private static final int THREAD_COUNT=30;  
    private static DateTimeFormatter formatter= 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.submit(()->{  
 try {  
 semaphore.acquire();  
 try{  
 DateTime.parse("2021-12-14",formatter).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("所有线程格式化日期成功");  
 }  
}

综上所示：解决SimpleDateFormat类的线程安全问题几种方案中，局部变量法由于线程每次执行格式化都要创建SimpleDateFormat类的对象，这会浪费运行空间和消耗服务器的性能，因为JVM创建和销毁对象是要耗费性能的。所以，不推荐在高并发要求的生产环境使用。

synchronized锁方式和Lock锁方式在处理问题的本质上是一致的，通过加锁的方式，使同一时刻只能有一个线程执行格式化日期和时间的操作。这种方式虽然减少了SimpleDateFormat对象的创建，但是由于同步锁的存在，导致性能下降，所以，不推荐在高并发要求的生产环境使用。

ThreadLocal通过保存各个线程的SimpleDateFormat类对象的副本，使每个线程在运行时，各自使用自身绑定的SimpleDateFormat对象，互不干扰，执行性能比较高，推荐在高并发的生产环境使用。

DateTimeFormatter是Java 8中提供的处理日期和时间的类，DateTimeFormatter类本身就是线程安全的。

joda-time是第三方处理日期和时间的类库，线程安全，性能经过高并发的考验，推荐在高并发场景下的生产环境使用。

picture.image

0
0
0
0
关于作者
风之馨技术录
风之馨技术录
关于作者
风之馨技术录
风之馨技术录

文章

0

获赞

0

收藏

0

相关资源
字节跳动云原生降本增效实践
本次分享主要介绍字节跳动如何利用云原生技术不断提升资源利用效率，降低基础设施成本；并重点分享字节跳动云原生团队在构建超大规模云原生系统过程中遇到的问题和相关解决方案，以及过程中回馈社区和客户的一系列开源项目和产品。
点击下载 
相关产品
推荐阅读
【Python常用函数】一文让你彻底掌握Python中的Map函数
shared_ptr 与 unique_ptr 的 deleter
RAG 检索算法：TF-IDF 和 BM25
pybind11 module
Python统计pdf中英文单词的个数
评论
未登录
看完啦，登录分享一下感受吧～
暂无评论