以SimpleDateFormat为例详解线程安全问题引发场景
前言
-
概念
线程安全，通俗点说，就是线程访问时不产生资源冲突。《java编程并发实践》中定义："一个类可以被多个线程安全调用就是线程安全的"
多线程下常见安全问题
静态变量：线程非安全
-
静态变量定义
使用static关键字定义的变量。static可以修饰变量和方法，也有static静态代码块。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它的类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。
-
静态变量应用场景
-
对象间共享值
-
方便访问变量
-
-
静态变量注意事项
-
不能在静态方法内使用非静态变量，即不能直接访问所属类的实例变量
-
不能在静态方法内直接调用非静态方法
-
静态方法中不能使用this和super关键字
-
-
案例说明
/** * @ClassName ThreadSafeDemo * @Description TODO 线程安全问题案例$ * @Author charlesYan * @Date 2020/6/14 20:44 * @Version 1.0 **/ public class ThreadSafeDemo implements Runnable { private static int num;//静态变量 @Override public void run() { num = 3; System.out.println("当前线程：" + Thread.currentThread().getName() + ", num的值: " + num); num = 5; System.out.println("当前线程：" + Thread.currentThread().getName() + ", num的值：" + num * 2); } public static void main(String[] args) { ThreadSafeDemo thread = new ThreadSafeDemo(); for (int i = 0; i < 1000; i++) { new Thread(thread,"Thread-" + i).start(); } } } // 部分输出结果 当前线程：Thread-670, num的值: 3 当前线程：Thread-670, num的值：10 当前线程：Thread-673, num的值: 3 当前线程：Thread-129, num的值: 5 当前线程：Thread-674, num的值: 3 当前线程：Thread-675, num的值: 3 当前线程：Thread-675, num的值：6 -
结论
静态变量也称为类变量，属于类对象所有，位于方法区，为所有对象共享，共享一份内存，一旦值被修改，则其他对象均对修改可见，故线程非安全
实例变量：单例时线程非安全，非单例时线程安全
-
实例变量定义
实例变量属于类对象的，属于对象实例私有，在虚拟机的堆中分配
-
单例案例说明
/** * @ClassName ThreadSafeDemo * @Description TODO 线程安全问题案例$ * @Author charlesYan * @Date 2020/6/14 20:44 * @Version 1.0 **/ public class ThreadSafeDemo implements Runnable { private int num;//实例变量 @Override public void run() { num = 3; System.out.println("当前线程：" + Thread.currentThread().getName() + ", num的值: " + num); num = 5; System.out.println("当前线程：" + Thread.currentThread().getName() + ", num的值：" + num * 2); } public static void main(String[] args) { ThreadSafeDemo thread = new ThreadSafeDemo(); for (int i = 0; i < 1000; i++) { new Thread(thread,"Thread-" + i).start(); } } } //局部输出结果 当前线程：Thread-109, num的值：10 当前线程：Thread-822, num的值: 3 当前线程：Thread-822, num的值：6 当前线程：Thread-728, num的值: 3 -
多例案例说明
/** * @ClassName ThreadSafeDemo * @Description TODO 线程安全问题案例$ * @Author charlesYan * @Date 2020/6/14 20:44 * @Version 1.0 **/ public class ThreadSafeDemo implements Runnable { private int num;//实例变量 @Override public void run() { num = 3; System.out.println("当前线程：" + Thread.currentThread().getName() + ", num的值: " + num); num = 5; System.out.println("当前线程：" + Thread.currentThread().getName() + ", num的值：" + num * 2); } public static void main(String[] args) { for (int i = 0; i < 2000; i++) { new Thread(new ThreadSafeDemo(),"Thread-" + i).start(); } } } //输出结果正常 当前线程：Thread-123, num的值: 3 当前线程：Thread-123, num的值：10 -
结论
实例变量是实例对象私有的：若系统只存在一个实例对象，则在多线程环境下，如果值改变后，则其它对象均可见，故线程非安全；如果每个线程都在不同的实例对象中执行，则对象与对象间的修改互不影响，故线程安全。
局部变量：线程安全
-
局部变量定义
定义在方法内部的变量
-
案例说明
/** * @ClassName ThreadSafeDemo * @Description TODO 线程安全问题案例$ * @Author charlesYan * @Date 2020/6/14 20:44 * @Version 1.0 **/ public class ThreadSafeDemo implements Runnable { @Override public void run() { int num;//局部变量 num = 3; System.out.println("当前线程：" + Thread.currentThread().getName() + ", num的值: " + num); num = 5; System.out.println("当前线程：" + Thread.currentThread().getName() + ", num的值：" + num * 2); } public static void main(String[] args) { ThreadSafeDemo threadSafe = new ThreadSafeDemo(); for (int i = 0; i < 2000; i++) { new Thread(threadSafe,"Thread-" + i).start(); } } } //输出结果显示无线程安全问题 -
结论
每个线程执行时都会把局部变量放在各自的帧栈的内存空间中，线程间不共享，故不存在线程安全问题。
静态方法的线程安全性
-
前言
之前在这块比较疑惑，总将静态方法和静态变量等同，认为封装的静态方法，在多个线程调用的时候，会出现资源抢占的情况，如日期工具类用SimpleDateFormat进行日期转换，后来通过多方查看博客总结，只要静态方法操作的不是共享资源就不会出现这种情况。
-
原因说明
静态方法内的变量，每个线程调用时，都会新创建一份，不会公用一个存储单元，故不存在线程冲突的问题。
-
结论
静态方法中如果没有使用静态变量，则没有线程安全的问题
SimpleDateFormat时间格式化存在线程安全问题
-
简介
DateFormat 和 SimpleDateFormat 类不都是线程安全的，在多线程环境下调用 format() 和 parse() 方法应该使用同步代码来避免问题
线程安全举例
-
前言
实际开发中应当尽量少的创建SimpleDateFormat 实例，因为创建这么一个实例需要耗费很大的代价。例如在一个读取数据库数据导出到excel文件的例子当中，每次处理一个时间信息的时候，就需要创建一个SimpleDateFormat实例对象，然后再丢弃这个对象。大量的对象就这样被创建出来，占用大量的内存和jvm空间。
那我就创建一个静态的simpleDateFormat实例，然后放到一个DateUtil类（如下）中，在使用时直接使用这个实例进行操作，这样问题就解决了。
-
单例案例代码
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class DateUtil { private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static String formatDate(Date date)throws ParseException{ return sdf.format(date); } public static Date parse(String strDate) throws ParseException{ return sdf.parse(strDate); } } -
测试代码
import java.text.ParseException; import java.util.Date; public class DateUtilTest { public static class TestSimpleDateFormatThreadSafe extends Thread { @Override public void run() { while(true) { try { this.join(2000); } catch (InterruptedException e1) { e1.printStackTrace(); } try { System.out.println(this.getName()+":"+DateUtil.parse("2013-05-24 06:02:20")); } catch (ParseException e) { e.printStackTrace(); } } } } public static void main(String[] args) { for(int i = 0; i < 3; i++){ new TestSimpleDateFormatThreadSafe().start(); } } } -
结果分析
当你在生产环境中使用一段时间之后，你就会发现这么一个事实：它不是线程安全的。在正常的测试情况之下，都没有问题，但一旦在生产环境中一定负载情况下时，这个问题就出来了。他会出现各种不同的情况，比如转化的时间不正确，比如报错，比如线程被挂死等等。
原因分析
-
文档注释
SimpleDateFormat中的日期格式不是同步的。推荐（建议）为每个线程创建独立的格式实例。如果多个线程同时访问一个格式，则它必须保持外部同步。
//JDK原始文档如下： Synchronization： Date formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally. -
源码分析
SimpleDateFormat继承了DateFormat,在DateFormat中定义了一个protected属性的Calendar类的对象：calendar。只是因为Calendar类的概念复杂，牵扯到时区与本地化等等，JDK的实现中使用了成员变量来传递参数，这就造成在多线程的时候会出现错误
// 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) { 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; }calendar.setTime(date)这条语句改变了calendar，稍后，calendar还会用到（在subFormat方法里），而这就是引发问题的根源
- 在一个多线程环境下，有两个线程持有了同一个SimpleDateFormat的实例，分别调用format方法：
- 线程1调用format方法，改变了calendar这个字段。
- 中断来了。
- 线程2开始执行，它也改变了calendar。
- 又中断了。
- 线程1回来了，此时，calendar已然不是它所设的值，而是走上了线程2设计的道路。如果多个线程同时争抢calendar对象，则会出现各种问题，时间不对，线程挂死等等。
分析一下format的实现，我们不难发现，用到成员变量calendar，唯一的好处，就是在调用subFormat时，少了一个参数，却带来了这许多的问题。其实，只要在这里用一个局部变量，一路传递下去，所有问题都将迎刃而解。
-
注意事项
-
自己写公用类的时候，要对多线程调用情况下的后果在注释里进行明确说明
-
对线程环境下，对每一个共享的可变变量都要注意其线程安全性
-
我们的类和方法在做设计的时候，要尽量设计成无状态的
-
-
无状态
无状态：无状态方法的好处之一，就是它在各种环境下，都可以安全的调用。衡量一个方法是否是有状态的，就看它是否改动了其它的东西，比如全局变量，比如实例的字段。format方法在运行过程中改动了SimpleDateFormat的calendar字段，所以，它是有状态的。
解决方案
创建多实例
-
案例代码
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class DateUtil { public static String formatDate(Date date)throws ParseException{ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); return sdf.format(date); } public static Date parse(String strDate) throws ParseException{ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); return sdf.parse(strDate); } } -
说明
在需要用到SimpleDateFormat 的地方新建一个实例，不管什么时候，将有线程安全问题的对象由共享变为局部私有都能避免多线程问题，不过也加重了创建对象的负担。在一般情况下，这样其实对性能影响比不是很明显的。
同步SimpleDateFormat对象
-
案例代码
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class DateSyncUtil { private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static String formatDate(Date date)throws ParseException{ synchronized(sdf){ return sdf.format(date); } } public static Date parse(String strDate) throws ParseException{ synchronized(sdf){ return sdf.parse(strDate); } } } -
说明
当线程较多时，当一个线程调用该方法时，其他想要调用此方法的线程就要block，多线程并发量大的时候会对性能有一定的影响
使用ThreadLocal
-
案例代码一
import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class ConcurrentDateUtil { private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>() { @Override protected DateFormat initialValue() { return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); } }; public static Date parse(String dateStr) throws ParseException { return threadLocal.get().parse(dateStr); } public static String format(Date date) { return threadLocal.get().format(date); } } -
案例代码二
import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class ThreadLocalDateUtil { private static final String date_format = "yyyy-MM-dd HH:mm:ss"; private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(); public static DateFormat getDateFormat(){ DateFormat df = threadLocal.get(); if(df==null){ df = new SimpleDateFormat(date_format); threadLocal.set(df); } return df; } public static String formatDate(Date date) throws ParseException { return getDateFormat().format(date); } public static Date parse(String strDate) throws ParseException { return getDateFormat().parse(strDate); } } -
说明
使用ThreadLocal也是将共享变量变为独享，线程独享肯定能比方法独享在并发环境中能减少不少创建对象的开销。如果对性能要求比较高的情况下，一般推荐使用这种方法。
使用其他类库中的时间格式化类(抛弃JDK)
-
FastDateFormat
使用Apache commons 里的FastDateFormat，宣称是既快又线程安全的SimpleDateFormat, 可惜它只能对日期进行format, 不能对日期串进行解析。
-
Joda-Time类库
使用Joda-Time类库来处理时间相关问题，Joda-Time类库对时间处理方式比较完美，建议使用
-
LocalDate
JDK1.8中新的时间API，并且是线程安全的
总结
-
性能分析
做一个简单的压力测试，方法一最慢，方法三最快。一般系统方法一和方法二就可以满足，如果在必要的时候，追求那么一点性能提升的话，可以考虑用方法三，用ThreadLocal做缓存。
参考链接
https://blog.51cto.com/longw/1683360
https://blog.csdn.net/lppl010_/article/details/84710101
https://blog.csdn.net/q669239799/article/details/90614077
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
