SimpleDateFormat的线程安全问题

已于 2024-08-16 14:32:03 修改
阅读量253 收藏 2
点赞数 2
分类专栏： Java基础 Java Web基础 文章标签： java 开发语言
于 2024-08-12 16:54:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pluto_CSND/article/details/141135971
版权

参考文章：https://blog.csdn.net/l1028386804/article/details/104397090

文章分析SimpleDateFormat作为公共变量时，高并发场景下，其format()或parse()函数的线程安全问题。

一、原理分析

查看源码，发现SimpleDateFormat的format()方法实际操作的就是Calendar变量。当声明SimpleDateFormat为static变量，那么它的Calendar变量也就是一个共享变量，可以被多个线程访问。

《DateFormat.java》源码

public final String format(Date date) {
	return format(date, new StringBuffer(), DontCareFieldPosition.INSTANCE).toString();
}

《SimpleDateFormat.java》源码

/**
 * The compiled pattern.
 */
transient private char[] compiledPattern = {260, 514}; // 'A', 'Ȃ'

/**
 * Tags for the compiled pattern.
 */
private final static int TAG_QUOTE_ASCII_CHAR       = 100;
private final static int TAG_QUOTE_CHARS            = 101;


@Override
public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition pos) {
	pos.beginIndex = pos.endIndex = 0;
	return format(date, toAppendTo, pos.getFieldDelegate());
}

// 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);

	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) {
			/// ASCII码
			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;
}

/**
 * Returns true if the DateFormatSymbols has been set explicitly or locale is null.
 */
private boolean useDateFormatSymbols() {
	return useDateFormatSymbols || locale == null; // useDateFormatSymbols=false, locale="zh-CN"
}

高并发场景下，假设线程A执行完calendar.setTime(date)，把时间设置成 “2024-07-26” 后线程被挂起；线程B获得CPU执行权限，也执行到了calendar.setTime(date)，把时间设置为 “2024-07-27” 后线程被挂起，线程A继续执行，calendar还会被继续使用subFormat()方法，而这时calendar用的是线程B设置的值了，此时就会引发问题，如时间不对，线程挂死等。

二、编码验证

CountDownLatch 类可以使一个线程等待其他线程各自执行完毕后再执行，这里使主线程等待子线程执行完毕。
Semaphore 类是计数信号量，被获取后必须由获取它的线程释放，可用来限制指定资源的访问线程数，如限流。

package *;

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;

/**
 * 测试SimpleDateFormat的线程安全问题
 */
public class SimpleDateFormatTest {
	
	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	
	// 线程总的执行次数
	private static final int EXECUTE_ACCOUNT = 1000;
	
	// 同时执行的线程数量
	private static final int THREAD_COUNT = 20;
	
	public static void main(String[] args) throws InterruptedException {
		
		final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_ACCOUNT);
	
	final Semaphore semaphore = new Semaphore(THREAD_COUNT);
	
	/// 定义线程池
	ExecutorService executorService = Executors.newCachedThreadPool();
	for (int i = 0; i < EXECUTE_ACCOUNT; i++){
		
		executorService.execute(() -> {
			
			try {
				// 获取信号
				semaphore.acquire();
				try {
					sdf.parse("2024-07-26");
				} catch (ParseException e) {
					System.out.println("线程：" + Thread.currentThread().getName() + " 解析日期失败");
					e.printStackTrace();
					System.exit(1);
				} catch (NumberFormatException 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("所有线程解析日期成功");
}
}

三、解决办法

1. 局部变量法

高并发场景下JVM会频繁创建、销毁SimpleDateFormat对象，影响程序的性能，生产环境不推荐使用；

2. synchronized 加锁

	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	
	try {
		synchronized (sdf){
			sdf.parse("2024-07-26");
		}
	} catch (ParseException e) {
		System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
		e.printStackTrace();
		System.exit(1);
	} catch (NumberFormatException e) {
		System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
		e.printStackTrace();
		System.exit(1);
	}

对同一个SimpleDateFormat对象加锁，使同一时刻只能有一个线程执行parse(String)方法。在高并发场景下会影响程序的执行性能，生产环境不推荐使用；

3. Lock 加锁

	private static Lock lock = new ReentrantLock();

	try {
		lock.lock();
		simpleDateFormat.parse("2024-07-26");
	} catch (ParseException e) {
		System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
		e.printStackTrace();
		System.exit(1);
	} catch (NumberFormatException e) {
		System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
		e.printStackTrace();
		System.exit(1);
	} finally {
		lock.unlock();
	}

同 synchronized 锁方式

4. ThreadLocal

    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>() {
		@Override
		protected DateFormat initialValue() {
			return new SimpleDateFormat("yyyy-MM-dd");
		}
	};
	
	try {
		threadLocal.get().parse("2024-07-26");
	} catch (ParseException e) {
		System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
		e.printStackTrace();
		System.exit(1);
	}catch (NumberFormatException e){
		System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
		e.printStackTrace();
		System.exit(1);
	}

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

TODO: 使用 threadLocal 时，需注意内存溢出问题，要记得释放内存 ！

5. DateTimeFormatter

    private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
   
	try {
		LocalDate.parse("2024-07-26", formatter);
	}catch (Exception e){
		System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失败");
		e.printStackTrace();
		System.exit(1);
	}
或
	private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    java.time.LocalDateTime.now().format(formatter);
    LocalDateTime.ofInstant(new Date().toInstant(), ZoneId.systemDefault()).format(formatter);

6. joda-time

Pluto_CSND
关注
专栏目录
SimpleDateFormat线程安全问题
upupfeng的博客
07-08 445
SimpleDateFormat是线程不安全的，在并发操作时可能会出现时间转换错误等情况。 之前总是听到说sdf是线程不安全的，也只是记下来，并不知道它为什么是不安全的。 今天在排查一个数据问题的时候，发现数据的总数是一样的，但是进行日期范围的筛选之后的结果是不一样的。突然想到，在处理数据的代码中使用到了sdf.format()方法，一番测试之后发现果真是sdf线程不安全导致的问题。在此记录一下...
SimpleDateFormat
zdw890412的专栏
05-30 566
诸位Java程序员，想必大家对SimpleDateFormat并不陌生。不过，你是否知道，SimpleDateFormat不是线程安全的（thread safe）。这意味着，下面的代码是错误的： class Sample {   private static final DateFormat format = new SimpleDateFormat("yyyy.MM.dd");   pub
SimpleDateFormat的线程安全性
义臻的博客
11-01 5852
SimpleDateFormat 是线程不安全类,在定义为static时可能出现线程安全问题；推荐使用DateUtils工具类。下面的示例将给出错误的和正确的代码。 首先是错误的代码，执行Demo会发现，在某些竞态条件下报错。   package wrong; import java.text.ParseException; import java.text.SimpleDateForma...
深入理解Java：SimpleDateFormat安全的时间格式化
weixin_33843947的博客
05-31 1797
　　想必大家对SimpleDateFormat并不陌生。SimpleDateFormat 是 Java 中一个非常常用的类，该类用来对日期字符串进行解析和格式化输出，但如果使用不小心会导致非常微妙和难以调试的问题，因为 DateFormat 和 SimpleDateFormat 类不都是线程安全的，在多线程环境下调用 format() 和 parse() 方法应该使用同步代码来避免问题。下面我们通...
Java SimpleDateFormat线程安全问题原理详解
08-19
Java SimpleDateFormat线程安全问题原理详解 Java SimpleDateFormat线程安全问题是Java开发中一个常见的问题。SimpleDateFormat是Java中一个常用的日期时间格式化类，但是它却存在线程安全问题。在多线程环境下，...
Java-SimpleDateFormat线程安全问题
FromZeroJiYuan的博客
11-22 3126
文章目录SimpleDateFormat使用示例SimpleDateFormat问题线程不安全解决方案使用局部变量使用全局变量 & 操作加锁使用ThreadLocal进行线程隔离JDK8-DateTimeFormatter用法 SimpleDateFormat java.text.SimpleDateFormat是常用的时间日期格式化和解析的Java类。 SimpleDateFormat支持到毫秒精度。 使用 SimpleDateFormat最常用的方法是格式化日期时间和解析日期时间。 publi
SimpleDateFormat 线程安全问题的六种解决方案
最新发布
m0_71777195的博客
08-30 161
综上所示：在解决解决 SimpleDateFormat 类的线程安全问题的几种方案中，局部变量法由于线程每次执行格式化时间时，都会创建 SimpleDateFormat 类的对象，这会导致创建大量的 SimpleDateFormat 对象，浪费运行空间和消耗服务器的性能，因为 JVM 创建和销毁对象是要耗费性能的。这种方式虽然减少了 SimpleDateFormat 对象的创建，但是由于同步锁的存在，导致性能下降，所以，不推荐在高并发要求的生产环境使用。所以，推荐在高并发场景下的生产环境使用。
Java基础---SimpleDateFormat的线程安全
汤键的博客
07-13 1436
Java基础---SimpleDateFormat的线程安全
SimpleDateFormat 类的线程安全问题
dh的博客
06-07 1298
提起 SimpleDateFormat 类，想必做过 Java 开发的童鞋都不会感到陌生。没错，它就是 Java 中提供的日期时间的转化类。这里，为什么说SimpleDateFormat 类有线程安全问题呢？有些小伙伴可能会提出疑问：我们生产环境上一直在使用 SimpleDateFormat 类来解析和格式化日期和时间类型的数据，一直都没有问题啊！我的回答是：没错，那是因为你们的系统达不到 SimpleDateFormat 类出现问题的并发量，也就是说你们的系统没啥负载！ 接下来，我们就一起看下在高并发下
SimpleDateFormat的线程安全性问题
Clearlove_S7的博客
06-04 1138
在日常开发中，我们经常会用到时间，我们有很多办法在Java代码中获取时间。但是不同的方法获取到的时间的格式都不尽相同，这时候就需要一种格式化工具，把时间显示成我们需要的格式。最常用的方法就是使用类。这是一个看上去功能比较简单的类，但是，一旦使用不当也有可能导致很大的问题。提起SimpleDateFormat类，想必做过Java开发的程序员都不会感到陌生。这里，为什么说Simple DateFormat 类有线程安全问题呢？
java 关于SimpleDateFormat线程安全问题
tonylii的博客
05-24 396
SimpleDateFormat 一般用于时间格式化操作，但是SimpleDateFormat本身是一个线程不安全的。 一般可能都会选择每个线程请求创建一个SimpleDateFormat实例，但是SimpleDateFormat获取是非常消耗志愿。在这种情况下 也许大多数人 获选择使用工具类的形式使用static的方式，如：public static final SimpleDateFormat
SimpleDateFormat与线程安全
zhaohong_bo的专栏
04-10 944
SimpleDateFormat不是线程安全的。 SimpleDateFormat(下面简称sdf)类内部有一个Calendar对象引用，它用来储存和这个sdf相关的日期信息，例如sdf.parse(dateStr)，sdf.format(date) 诸如此类的方法参数传入的日期相关String, Date等等， 都是交由Calendar引用来存储的。这样就会导致一个问题，如果多个线程共享sdf，...
SimpleDateFormat 线程安全问题
Dy-修补匠的博客
03-15 236
在项目中,经常需要将日期在String和Date之间做转化,此时需要使用SimpleDateFormat类。使用SimpleDateFormat类的parse方法，可以将满足格式要求的字符串转换成Date对象，使用SimpleDateFormat类的format方法，可以将Date类型的对象转换成一定格式的字符串。 重点注意：SimpleDateFormat并非是线程安全的。 1.测试代码 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值