解决SimpleDateFormat线程不安全问题

JDK文档有这么一段关于SimpleDateFormat的描述

 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会有线程安全问题；

• 为啥呢？看下SimpleDateFormat方法的源码

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;
    }

       发现使用了成员变量calenda，来保存时间，后面的逻辑使用了这个成员变量，这些操作是非原子性的；

      当我们在声明使用一个共享变量SimpleDateFormat的时候，SimpleDateFormat中的calendar也就可以被多个线程访问到。加入线程A执行到calendar.setTime(date)还未往下执行，此刻线程B也开始执行calendar.setTime(date)，这时线程A继续往下执行，但此时calendar的值已经被线程B设置的新值（calendar需要由线程A设置的值才能返回正确预期值），这样就产生了错误的结果值；

除了format方法以外，SimpleDateFormat的parse方法也有同样的问题。

• 如何解决呢？

使用ThreadLocal， ThreadLocal 可以确保每个线程都有自己单独的一个 SimpleDateFormat 对象，这样也就不存在多个线程同时访问SimpleDateFormat方法了。

示例代码：

import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Supplier;

/**
 * Application
 *
 * @Author Gavin
 * @Date 2021/11/3 10:17
 * @Description 描述
 * @Version 1.0
 */
public class Application {
    static SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    static int count=1000;
    /**
     * 定义一个CountDownLatch，保证所有子线程执行完之后主线程再执行
     */
    private static CountDownLatch countDownLatch = new CountDownLatch(count);
    public static void main(String[] args) throws Exception {
        //保存产生的结果，用来对比实际结果与预期是否正确
        final Set<String> r = Collections.synchronizedSet(new HashSet());
        ExecutorService executorService=Executors.newFixedThreadPool(10);
        for(int i=0;i<count;i++) {
            final Integer finalI=i;
            executorService.submit(() -> {
                String s = date(finalI);
                r.add(s);
                System.out.println(s);
                //执行完毕一个线程
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        System.out.println("==="+r.size());
    }
    public static String date(int seconds){
        Date date=new Date(1000*seconds);
        //线程安全
        String str=common.formatter.get().format(date);
        //线程不安全
        //String str=simpleDateFormat.format(date);
        return str;
    }
}
class common{
    public static ThreadLocal<SimpleDateFormat> formatter=ThreadLocal.withInitial((Supplier) () -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
}

当然也可以通过其他方式，比如加锁（排队等待，降低并发性能），使用局部变量（避免资源竞争）等方法解决线程安全问题