SimpleDateFormat并发引发的multiple points 异常以及解决

一、问题分析

SimpleDateFormat并发会出现如下问题：

1、java.lang.NumberFormatException: multiple points

2、 java.lang.NumberFormatException: empty String

3、java.lang.NumberFormatException: For input string: ""

二、原因分析

追究根源:

　　SimpleDateFormat的format方法和parse方法都因为使用calendar来操作时间，
　　而calendar是共享变量，并且这个共享变量没有做线程安全控制；
源码分析：

（1）format方法：

当多个线程同时使用相同的SimpleDateFormat对象【用static修饰的SimpleDateFormat】调用format方法时，多个线程会同时调用calendar.setTime方法，可能一个线程刚设置好time值，另外的一个线程马上把设置的time值给修改了导致返回的格式化时间可能是错误的。

（2）parse方法：

parse方法实际调用alb.establish(calendar).getTime()方法来解析，
alb.establish(calendar)方法里主要任务是：

重置日期对象cal的属性值
使用calb中中属性设置cal
返回设置好的cal对象

在parse方法的最后，会调用CalendarBuilder的establish方法，入参就是SimpleDateFormat维护的Calendar实例，
在establish方法中会调用calendar的clear方法；
SimpleDateFormat维护的用于format和parse方法处理时间的calendar被清空了；
如果此时线程A将calendar清空且没有设置新值，线程B也进入parse方法用到了SimpleDateFormat对象中的calendar对象，此时就会产生线程安全问题！

三、解决方案

（1）将 SimpleDateFormat 定义为局部变量；

　　特点：创建和销毁对象的开销大；
（2）使用 synchronized 加锁执行；

　　特点：线程阻塞性能差；
（3）使用 Lock 加锁执行（和解决方案 2 类似）；

　　特点：线程阻塞性能差；
（4）使用 ThreadLocal；

　　特点：较好的方法；
（5）使用 JDK 8 中提供的 DateTimeFormat。Java8新增的 LocalDate、LocalTime、LocalDateTime；

　　例如：LocalDateTime.parse("20230329125957", DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
　　　　Instant 代替Date, LocalDateTime代替Calendar, DateTimeFormat代替SimpleDateFormat；

解决方案的具体实现：

1、将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();
    }
}

2、使用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();
    }
}

3、使用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();
    }
}

4、使用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 不等于局部变量，这里的“局部变量”指的是像 1示例代码中的局部变量， ThreadLocal 和局部变量最大的区别在于：ThreadLocal 属于线程的私有变量，如果使用的是线程池，那么 ThreadLocal 中的变量是可以重复使用的，而代码级别的局部变量，每次执行时都会创建新的局部变量，二者区别如下图所示：

5、使用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();
    }
}

其他示例：

// 线程安全,Java8新增的 LocalDate、LocalTime、LocalDateTime
// Instant 代替Date, LocalDateTime代替Calendar, DateTimeFormat代替SimpleDateFormat；
log.info("===2============={}", LocalDateTime.parse("20230329125957",  DateTimeFormatter.ofPattern("yyyyMMddHHmmss")));
log.info("===3============={}", LocalDate.parse("20230329",  DateTimeFormatter.ofPattern("yyyyMMdd")));
log.info("===4============={}", LocalDateTime.now());
log.info("===5============={}", Instant.now());
log.info("===6============={}", LocalDate.now());
log.info("===6-1============={}", LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")));
log.info("===6-2-明天============={}", LocalDate.now().plusDays(1).format(DateTimeFormatter.ofPattern(
    "yyyyMMdd")));
log.info("===6-3-后天============={}", LocalDate.now().plusDays(2).format(DateTimeFormatter.ofPattern(
    "yyyyMMdd")));