百度360必应搜狗淘宝本站头条
python判断字典是否为空crontab每周一执行aes和des区别安装指定版本npmadb pull
当前位置：网站首页 > IT知识 > 正文

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

liuian 2025-07-01 21:19 26 浏览

1.什么是线程不安全？

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


线程不安全的代码

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

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleDateFormatExample {
    // 创建 SimpleDateFormat 对象
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");

    public static void main(String[] args) {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        // 执行 10 次时间格式化
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            // 线程池执行任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 创建时间对象
                    Date date = new Date(finalI * 1000);
                    // 执行时间格式化并打印结果
                    System.out.println(simpleDateFormat.format(date));
                }
            });
        }
    }
}

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

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

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


2.解决方案

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

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

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

① 将SimpleDateFormat变为局部变量

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

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleDateFormatExample {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        // 执行 10 次时间格式化
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            // 线程池执行任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 创建 SimpleDateFormat 对象
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
                    // 创建时间对象
                    Date date = new Date(finalI * 1000);
                    // 执行时间格式化并打印结果
                    System.out.println(simpleDateFormat.format(date));
                }
            });
        }
        // 任务执行完之后关闭线程池
        threadPool.shutdown();
    }
}

以上程序的执行结果为：

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


② 使用synchronized加锁

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

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleDateFormatExample2 {
    // 创建 SimpleDateFormat 对象
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");

    public static void main(String[] args) {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        // 执行 10 次时间格式化
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            // 线程池执行任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 创建时间对象
                    Date date = new Date(finalI * 1000);
                    // 定义格式化的结果
                    String result = null;
                    synchronized (simpleDateFormat) {
                        // 时间格式化
                        result = simpleDateFormat.format(date);
                    }
                    // 打印结果
                    System.out.println(result);
                }
            });
        }
        // 任务执行完之后关闭线程池
        threadPool.shutdown();
    }
}

以上程序的执行结果为：

③ 使用Lock加锁

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

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Lock 解决线程不安全问题
 */
public class SimpleDateFormatExample3 {
    // 创建 SimpleDateFormat 对象
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");

    public static void main(String[] args) {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        // 创建 Lock 锁
        Lock lock = new ReentrantLock();
        // 执行 10 次时间格式化
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            // 线程池执行任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 创建时间对象
                    Date date = new Date(finalI * 1000);
                    // 定义格式化的结果
                    String result = null;
                    // 加锁
                    lock.lock();
                    try {
                        // 时间格式化
                        result = simpleDateFormat.format(date);
                    } finally {
                        // 释放锁
                        lock.unlock();
                    }
                    // 打印结果
                    System.out.println(result);
                }
            });
        }
        // 任务执行完之后关闭线程池
        threadPool.shutdown();
    }
}

以上程序的执行结果为：

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

④ 使用ThreadLocal

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

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


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

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

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * ThreadLocal 解决线程不安全问题
 */
public class SimpleDateFormatExample4 {
    // 创建 ThreadLocal 对象，并设置默认值（new SimpleDateFormat）
    private static ThreadLocal<SimpleDateFormat> threadLocal =
            ThreadLocal.withInitial(() -> new SimpleDateFormat("mm:ss"));

    public static void main(String[] args) {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        // 执行 10 次时间格式化
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            // 线程池执行任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 创建时间对象
                    Date date = new Date(finalI * 1000);
                    // 格式化时间
                    String result = threadLocal.get().format(date);
                    // 打印结果
                    System.out.println(result);
                }
            });
        }
        // 任务执行完之后关闭线程池
        threadPool.shutdown();
    }
}

以上程序的执行结果为：

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 来格式化时间，具体实现代码如下：

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * DateTimeFormatter 解决线程不安全问题
 */
public class SimpleDateFormatExample5 {
    // 创建 DateTimeFormatter 对象
    private static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("mm:ss");

    public static void main(String[] args) {
        // 创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        // 执行 10 次时间格式化
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            // 线程池执行任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 创建时间对象
                    Date date = new Date(finalI * 1000);
                    // 将 Date 转换成 JDK 8 中的时间类型 LocalDateTime
                    LocalDateTime localDateTime =
                            LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
                    // 时间格式化
                    String result = dateTimeFormatter.format(localDateTime);
                    // 打印结果
                    System.out.println(result);
                }
            });
        }
        // 任务执行完之后关闭线程池
        threadPool.shutdown();
    }
}

以上程序的执行结果为：

3.线程不安全原因分析

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

private StringBuffer format(Date date, StringBuffer toAppendTo,
                                FieldDelegate delegate) {
    // 注意此行代码
    calendar.setTime(date);

    boolean useDateFormatSymbols = useDateFormatSymbols();

    for (int i = 0; i < compiledPattern.length; ) {
        int tag = compiledPattern[i] >>> 8;
        int count = compiledPattern[i++] & 0xff;
        if (count == 255) {
            count = compiledPattern[i++] << 16;
            count |= compiledPattern[i++];
        }

        switch (tag) {
            case TAG_QUOTE_ASCII_CHAR:
                toAppendTo.append((char)count);
                break;

            case TAG_QUOTE_CHARS:
                toAppendTo.append(compiledPattern, i, count);
                i += count;
                break;

            default:
                subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);
                break;
        }
    }
    return toAppendTo;
}

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


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

  1. 线程 1 执行了 calendar.setTime(date) 方法，将用户输入的时间转换成了后面格式化时所需要的时间；
  2. 线程 1 暂停执行，线程 2 得到 CPU 时间片开始执行；
  3. 线程 2 执行了 calendar.setTime(date) 方法，对时间进行了修改；
  4. 线程 2 暂停执行，线程 1 得出 CPU 时间片继续执行，因为线程 1 和线程 2 使用的是同一对象，而时间已经被线程 2 修改了，所以此时当线程 1 继续执行的时候就会出现线程安全的问题了。


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


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

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


4.各方案优缺点总结

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

相关推荐

MySQL慢查询优化:从explain到索引，DBA手把手教你提升10倍性能

数据库性能是应用系统的生命线，而慢查询就像隐藏在系统中的定时炸弹。某电商平台曾因一条未优化的SQL导致订单系统响应时间从200ms飙升至8秒，最终引发用户投诉和订单流失。今天我们就来系统学习MySQL...

一文读懂SQL五大操作类别(DDL/DML/DQL/DCL/TCL)的基础语法

在SQL中，DDL、DML、DQL、DCL、TCL是按操作类型划分的五大核心语言类别，缩写及简介如下：DDL（DataDefinitionLanguage，数据定义语言）：用于定义和管理数据库结构...

闲来无事，学学Mysql增、删，改，查

Mysql增、删，改，查1“增”——添加数据1.1为表中所有字段添加数据1.1.1INSERT语句中指定所有字段名语法：INSERTINTO表名（字段名1，字段名2，…）VALUES（值1...

数据库:MySQL 高性能优化规范建议

数据库命令规范所有数据库对象名称必须使用小写字母并用下划线分割所有数据库对象名称禁止使用MySQL保留关键字（如果表名中包含关键字查询时，需要将其用单引号括起来）数据库对象的命名要能做到见名识意，...

下载工具合集_下载工具手机版

迅雷，在国内的下载地位还是很难撼动的，所需要用到的地方还挺多。缺点就是不开会员，软件会限速。EagleGet，全能下载管理器，支持HTTP(S)FTPMMSRTSP协议，也可以使用浏览器扩展检测...

mediamtx v1.15.2 更新详解:功能优化与问题修复

mediamtxv1.15.2已于2025年10月14日发布，本次更新在功能、性能优化以及问题修复方面带来了多项改进，同时也更新了部分依赖库并提升了安全性。以下为本次更新的详细内容：...

声学成像仪:泄露监测 “雷达” 方案开启精准防控

声学成像仪背景将声像图与阵列上配装的摄像实所拍的视频图像以透明的方式叠合在一起，就形成了可直观分析被测物产生状态。这种利用声学、电子学和信息处理等技术，变换成人眼可见的图像的技术可以帮助人们直观地认识...

最稳存储方案:两种方法将摄像头接入威联通Qu405，录像不再丢失

今年我家至少被4位邻居敲门，就是为了查监控！！！原因是小区内部监控很早就停止维护了，半夜老有小黄毛掰车门偷东西，还有闲的没事划车的，车主损失不小，我家很早就配备监控了，人来亮灯有一定威慑力，不过监控设...

离岗检测算法_离岗检查内容

一、研发背景如今社会许多岗位是严禁随意脱离岗位的，如塔台、保安室、监狱狱警监控室等等，因为此类行为可能会引起重大事故，而此类岗位监督管理又有一定困难，因此促生了智能视频识别系统的出现。二、产品概述及工...

消防安全通道占用检测报警系统_消防安全通道占用检测报警系统的作用

一、产品概述科缔欧消防安全通道占用检测报警系统，是创新行业智能监督管理方式、完善监管部门动态监控及预警预报体系的信息化手段，是实现平台远程监控由“人为监控”向“智能监控”转变的必要手段。产品致力于设...

外出住酒店、民宿如何使用手机检测隐藏的监控摄像头

最近，一个家庭在他们的民宿收到了一个大惊喜：客厅里有一个伪装成烟雾探测器的隐藏摄像头，监视着他们的一举一动。隐藏摄像头的存在如果您住在酒店或民宿，隐藏摄像头不应再是您的担忧。对于民宿，房东应报告所有可...

基于Tilera众核平台的流媒体流量发生系统的设计

曾帅，高宗彬，赵国锋（重庆邮电大学通信与信息工程学院，重庆400065）摘要：设计了一种基于Tilera众核平台高强度的流媒体流量发生系统架构，其主要包括：系统界面管理模块、服务承载模块和流媒体...

使用ffmpeg将rtsp流转流实现h5端播放

1.主要实现rtsp转tcp协议视频流播放ffmpeg下载安装（公认业界视频处理大佬）a、官网地址：www.ffmpeg.org/b、gitHub：github.com/FFmpeg/FFmp…c、推...

将摄像头视频流从Rtsp协议转为websocket协议

写在前面很多通过摄像头拿到的视频流格式都是Rtsp协议的，比如：海康威视摄像头。在现代的浏览器中，已经不支持直接播放Rtsp视频流，而且，海康威视提供的本身的webSdk3.3.0视频插件有很多...

华芸科技推出安全监控中心2.1 Beta测试版

全球独家支持hdmi在线实时监看摄像机画面，具单一、循环或同时监看四频道视频影像，可透过华芸专用红外线遥控器、airemote或是键盘鼠标进行操作，提供摄像机频道增购服务，满足用户弹性扩增频道需...

一周热门
最近发表
标签列表