文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

SimpleDateFormat线程不安全的5种解决方案！

2024-12-03 04:27

关注

1.什么是线程不安全?

线程不安全也叫非线程安全，是指多线程执行中，程序的执行结果和预期的结果不符的情况就叫着线程不安全。

线程不安全的代码

SimpleDateFormat 就是一个典型的线程不安全事例，接下来我们动手来实现一下。首先我们先创建 10 个线程来格式化时间，时间格式化每次传递的待格式化时间都是不同的，所以程序如果正确执行将会打印 10 个不同的值，接下来我们来看具体的代码实现：

  1. import java.text.SimpleDateFormat; 
  2. import java.util.Date; 
  3. import java.util.concurrent.ExecutorService; 
  4. import java.util.concurrent.Executors; 
  5.  
  6. public class SimpleDateFormatExample { 
  7.     // 创建 SimpleDateFormat 对象 
  8.     private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); 
  9.  
  10.     public static void main(String[] args) { 
  11.         // 创建线程池 
  12.         ExecutorService threadPool = Executors.newFixedThreadPool(10); 
  13.         // 执行 10 次时间格式化 
  14.         for (int i = 0; i < 10; i++) { 
  15.             int finalI = i; 
  16.             // 线程池执行任务 
  17.             threadPool.execute(new Runnable() { 
  18.                 @Override 
  19.                 public void run() { 
  20.                     // 创建时间对象 
  21.                     Date date = new Date(finalI * 1000); 
  22.                     // 执行时间格式化并打印结果 
  23.                     System.out.println(simpleDateFormat.format(date)); 
  24.                 } 
  25.             }); 
  26.         } 
  27.     } 
  28. } 

我们预期的正确结果是这样的(10 次打印的值都不同)：

然而，以上程序的运行结果却是这样的：

从上述结果可以看出，当在多线程中使用 SimpleDateFormat 进行时间格式化是线程不安全的。

2.解决方案

SimpleDateFormat 线程不安全的解决方案总共包含以下 5 种：

  1. 将 SimpleDateFormat 定义为局部变量;
  2. 使用 synchronized 加锁执行;
  3. 使用 Lock 加锁执行(和解决方案 2 类似);
  4. 使用 ThreadLocal;
  5. 使用 JDK 8 中提供的 DateTimeFormat。

接下来我们分别来看每种解决方案的具体实现。

① SimpleDateFormat改为局部变量

将 SimpleDateFormat 定义为局部变量时，因为每个线程都是独享 SimpleDateFormat 对象的，相当于将多线程程序变成“单线程”程序了，所以不会有线程不安全的问题，具体实现代码如下：

  1. import java.text.SimpleDateFormat; 
  2. import java.util.Date; 
  3. import java.util.concurrent.ExecutorService; 
  4. import java.util.concurrent.Executors; 
  5.  
  6. public class SimpleDateFormatExample { 
  7.     public static void main(String[] args) { 
  8.         // 创建线程池 
  9.         ExecutorService threadPool = Executors.newFixedThreadPool(10); 
  10.         // 执行 10 次时间格式化 
  11.         for (int i = 0; i < 10; i++) { 
  12.             int finalI = i; 
  13.             // 线程池执行任务 
  14.             threadPool.execute(new Runnable() { 
  15.                 @Override 
  16.                 public void run() { 
  17.                     // 创建 SimpleDateFormat 对象 
  18.                     SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); 
  19.                     // 创建时间对象 
  20.                     Date date = new Date(finalI * 1000); 
  21.                     // 执行时间格式化并打印结果 
  22.                     System.out.println(simpleDateFormat.format(date)); 
  23.                 } 
  24.             }); 
  25.         } 
  26.         // 任务执行完之后关闭线程池 
  27.         threadPool.shutdown(); 
  28.     } 
  29. } 

以上程序的执行结果为：

当打印的结果都不相同时，表示程序的执行是正确的，从上述结果可以看出，将 SimpleDateFormat 定义为局部变量之后，就可以成功的解决线程不安全问题了。

② 使用synchronized加锁

锁是解决线程不安全问题最常用的手段，接下来我们先用 synchronized 来加锁进行时间格式化，实现代码如下：

  1. import java.text.SimpleDateFormat; 
  2. import java.util.Date; 
  3. import java.util.concurrent.ExecutorService; 
  4. import java.util.concurrent.Executors; 
  5.  
  6. public class SimpleDateFormatExample2 { 
  7.     // 创建 SimpleDateFormat 对象 
  8.     private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); 
  9.  
  10.     public static void main(String[] args) { 
  11.         // 创建线程池 
  12.         ExecutorService threadPool = Executors.newFixedThreadPool(10); 
  13.         // 执行 10 次时间格式化 
  14.         for (int i = 0; i < 10; i++) { 
  15.             int finalI = i; 
  16.             // 线程池执行任务 
  17.             threadPool.execute(new Runnable() { 
  18.                 @Override 
  19.                 public void run() { 
  20.                     // 创建时间对象 
  21.                     Date date = new Date(finalI * 1000); 
  22.                     // 定义格式化的结果 
  23.                     String result = null; 
  24.                     synchronized (simpleDateFormat) { 
  25.                         // 时间格式化 
  26.                         result = simpleDateFormat.format(date); 
  27.                     } 
  28.                     // 打印结果 
  29.                     System.out.println(result); 
  30.                 } 
  31.             }); 
  32.         } 
  33.         // 任务执行完之后关闭线程池 
  34.         threadPool.shutdown(); 
  35.     } 
  36. } 

以上程序的执行结果为：

③ 使用Lock加锁

在 Java 语言中，锁的常用实现方式有两种，除了 synchronized 之外，还可以使用手动锁 Lock，接下来我们使用 Lock 来对线程不安全的代码进行改造，实现代码如下：

  1. import java.text.SimpleDateFormat; 
  2. import java.util.Date; 
  3. import java.util.concurrent.ExecutorService; 
  4. import java.util.concurrent.Executors; 
  5. import java.util.concurrent.locks.Lock; 
  6. import java.util.concurrent.locks.ReentrantLock; 
  7.  
  8.  
  9. public class SimpleDateFormatExample3 { 
  10.     // 创建 SimpleDateFormat 对象 
  11.     private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); 
  12.  
  13.     public static void main(String[] args) { 
  14.         // 创建线程池 
  15.         ExecutorService threadPool = Executors.newFixedThreadPool(10); 
  16.         // 创建 Lock 锁 
  17.         Lock lock = new ReentrantLock(); 
  18.         // 执行 10 次时间格式化 
  19.         for (int i = 0; i < 10; i++) { 
  20.             int finalI = i; 
  21.             // 线程池执行任务 
  22.             threadPool.execute(new Runnable() { 
  23.                 @Override 
  24.                 public void run() { 
  25.                     // 创建时间对象 
  26.                     Date date = new Date(finalI * 1000); 
  27.                     // 定义格式化的结果 
  28.                     String result = null; 
  29.                     // 加锁 
  30.                     lock.lock(); 
  31.                     try { 
  32.                         // 时间格式化 
  33.                         result = simpleDateFormat.format(date); 
  34.                     } finally { 
  35.                         // 释放锁 
  36.                         lock.unlock(); 
  37.                     } 
  38.                     // 打印结果 
  39.                     System.out.println(result); 
  40.                 } 
  41.             }); 
  42.         } 
  43.         // 任务执行完之后关闭线程池 
  44.         threadPool.shutdown(); 
  45.     } 
  46. } 

以上程序的执行结果为：

从上述代码可以看出，手动锁的写法相比于 synchronized 要繁琐一些。

④ 使用ThreadLocal

加锁方案虽然可以正确的解决线程不安全的问题，但同时也引入了新的问题，加锁会让程序进入排队执行的流程，从而一定程度的降低了程序的执行效率，如下图所示：

那有没有一种方案既能解决线程不安全的问题，同时还可以避免排队执行呢?

答案是有的，可以考虑使用 ThreadLocal。ThreadLocal 翻译为中文是线程本地变量的意思，字如其人 ThreadLocal 就是用来创建线程的私有(本地)变量的，每个线程拥有自己的私有对象，这样就可以避免线程不安全的问题了，实现如下：

知道了实现方案之后，接下来我们使用具体的代码来演示一下 ThreadLocal 的使用，实现代码如下：

  1. import java.text.SimpleDateFormat; 
  2. import java.util.Date; 
  3. import java.util.concurrent.ExecutorService; 
  4. import java.util.concurrent.Executors; 
  5.  
  6.  
  7. public class SimpleDateFormatExample4 { 
  8.     // 创建 ThreadLocal 对象，并设置默认值（new SimpleDateFormat） 
  9.     private static ThreadLocal threadLocal = 
  10.             ThreadLocal.withInitial(() -> new SimpleDateFormat("mm:ss")); 
  11.  
  12.     public static void main(String[] args) { 
  13.         // 创建线程池 
  14.         ExecutorService threadPool = Executors.newFixedThreadPool(10); 
  15.         // 执行 10 次时间格式化 
  16.         for (int i = 0; i < 10; i++) { 
  17.             int finalI = i; 
  18.             // 线程池执行任务 
  19.             threadPool.execute(new Runnable() { 
  20.                 @Override 
  21.                 public void run() { 
  22.                     // 创建时间对象 
  23.                     Date date = new Date(finalI * 1000); 
  24.                     // 格式化时间 
  25.                     String result = threadLocal.get().format(date); 
  26.                     // 打印结果 
  27.                     System.out.println(result); 
  28.                 } 
  29.             }); 
  30.         } 
  31.         // 任务执行完之后关闭线程池 
  32.         threadPool.shutdown(); 
  33.     } 
  34. } 

以上程序的执行结果为：

ThreadLocal和局部变量的区别

首先来说 ThreadLocal 不等于局部变量，这里的“局部变量”指的是像 2.1 示例代码中的局部变量， ThreadLocal 和局部变量最大的区别在于：ThreadLocal 属于线程的私有变量，如果使用的是线程池，那么 ThreadLocal 中的变量是可以重复使用的，而代码级别的局部变量，每次执行时都会创建新的局部变量，二者区别如下图所示：

更多关于 ThreadLocal 的内容，可以访问磊哥前面的文章《ThreadLocal不好用?那是你没用对!》。

⑤ 使用DateTimeFormatter

以上 4 种解决方案都是因为 SimpleDateFormat 是线程不安全的，所以我们需要加锁或者使用 ThreadLocal 来处理，然而，JDK 8 之后我们就有了新的选择，如果使用的是 JDK 8+ 版本，就可以直接使用 JDK 8 中新增的、安全的时间格式化工具类 DateTimeFormatter 来格式化时间了，接下来我们来具体实现一下。

使用 DateTimeFormatter 必须要配合 JDK 8 中新增的时间对象 LocalDateTime 来使用，因此在操作之前，我们可以先将 Date 对象转换成 LocalDateTime，然后再通过 DateTimeFormatter 来格式化时间，具体实现代码如下：

  1. import java.time.LocalDateTime; 
  2. import java.time.ZoneId; 
  3. import java.time.format.DateTimeFormatter; 
  4. import java.util.Date; 
  5. import java.util.concurrent.ExecutorService; 
  6. import java.util.concurrent.Executors; 
  7.  
  8.  
  9. public class SimpleDateFormatExample5 { 
  10.     // 创建 DateTimeFormatter 对象 
  11.     private static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("mm:ss"); 
  12.  
  13.     public static void main(String[] args) { 
  14.         // 创建线程池 
  15.         ExecutorService threadPool = Executors.newFixedThreadPool(10); 
  16.         // 执行 10 次时间格式化 
  17.         for (int i = 0; i < 10; i++) { 
  18.             int finalI = i; 
  19.             // 线程池执行任务 
  20.             threadPool.execute(new Runnable() { 
  21.                 @Override 
  22.                 public void run() { 
  23.                     // 创建时间对象 
  24.                     Date date = new Date(finalI * 1000); 
  25.                     // 将 Date 转换成 JDK 8 中的时间类型 LocalDateTime 
  26.                     LocalDateTime localDateTime = 
  27.                             LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()); 
  28.                     // 时间格式化 
  29.                     String result = dateTimeFormatter.format(localDateTime); 
  30.                     // 打印结果 
  31.                     System.out.println(result); 
  32.                 } 
  33.             }); 
  34.         } 
  35.         // 任务执行完之后关闭线程池 
  36.         threadPool.shutdown(); 
  37.     } 
  38. } 

以上程序的执行结果为：

3.线程不安全原因分析

要了解 SimpleDateFormat 为什么是线程不安全的?我们需要查看并分析 SimpleDateFormat 的源码才行，那我们先从使用的方法 format 入手，源码如下：

  1. private StringBuffer format(Date date, StringBuffer toAppendTo, 
  2.                                 FieldDelegate delegate) { 
  3.     // 注意此行代码 
  4.     calendar.setTime(date); 
  5.  
  6.     boolean useDateFormatSymbols = useDateFormatSymbols(); 
  7.  
  8.     for (int i = 0; i < compiledPattern.length; ) { 
  9.         int tag = compiledPattern[i] >>> 8; 
  10.         int count = compiledPattern[i++] & 0xff; 
  11.         if (count == 255) { 
  12.             count = compiledPattern[i++] << 16; 
  13.             count |= compiledPattern[i++]; 
  14.         } 
  15.  
  16.         switch (tag) { 
  17.             case TAG_QUOTE_ASCII_CHAR: 
  18.                 toAppendTo.append((char)count); 
  19.                 break; 
  20.  
  21.             case TAG_QUOTE_CHARS: 
  22.                 toAppendTo.append(compiledPattern, i, count); 
  23.                 i += count; 
  24.                 break; 
  25.  
  26.             default: 
  27.                 subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols); 
  28.                 break; 
  29.         } 
  30.     } 
  31.     return toAppendTo; 
  32. } 

也许是好运使然，没想到刚开始分析第一个方法就找到了线程不安全的问题所在。

从上述源码可以看出，在执行 SimpleDateFormat.format 方法时，会使用 calendar.setTime 方法将输入的时间进行转换，那么我们想象一下这样的场景：

正常的情况下，程序的执行是这样的：

非线程安全的执行流程是这样的：

在多线程执行的情况下，线程 1 的 date1 和线程 2 的 date2，因为执行顺序的问题，最终都被格式化成 date2 formatted，而非线程 1 date1 formatted 和线程 2 date2 formatted，这样就会导致线程不安全的问题。

4.各方案优缺点总结

如果使用的是 JDK 8+ 版本，可以直接使用线程安全的 DateTimeFormatter 来进行时间格式化，如果使用的 JDK 8 以下版本或者改造老的 SimpleDateFormat 代码，可以考虑使用 synchronized 或 ThreadLocal 来解决线程不安全的问题。因为实现方案 1 局部变量的解决方案，每次执行的时候都会创建新的对象，因此不推荐使用。synchronized 的实现比较简单，而使用 ThreadLocal 可以避免加锁排队执行的问题。

 

来源：Java中文社群内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

SimpleDateFormat线程不安全的5种解决方案！

后端开发SimpleDateFormat线程2024-12-03

java的SimpleDateFormat线程不安全的几种解决方案

后端开发2024-04-02

解决Java中SimpleDateFormat线程不安全的五种方案

后端开发2024-04-02

详解SimpleDateFormat的线程安全问题与解决方案

后端开发2023-05-31

Java SimpleDateFormat线程不安全问题怎么解决

后端开发2023-07-05

如何解决Java中SimpleDateFormat线程不安全的问题

后端开发2023-06-15

simpledateformat线程不安全的原因

后端开发2023-06-15

java的SimpleDateFormat线程不安全怎么办

后端开发2023-06-20

Java线程安全问题的解决方案

后端开发2024-04-02

Java中关于线程安全的三种解决方式

后端开发2024-04-02

Java多线程高并发中解决ArrayList与HashSet和HashMap不安全的方案

后端开发2024-04-02

stringbuffer线程不安全怎么解决

后端开发2023-09-15

3/4G无线接入安全解决方案

后端开发2023-01-31

JavaEE的进程,线程和创建线程的5种方式详解

后端开发2024-04-02

面试突击：线程安全问题的解决方案有哪些？

后端开发线程安全2024-12-02

阿里云服务器不安全的解决方案

阿里云服务器不安全的解决方案
后端开发2024-01-21

单例模式在并发环境中的线程安全性解决方案

后端开发2023-10-21

win7安全模式不弹出cmd解决方案

后端开发2023-07-16

你需要了解的5种数据库扩展解决方案

后端开发数据库扩展2024-12-11

java多线程题目的解决方案

后端开发2023-06-17
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯