关于java:SimpleDateFormat线程不安全的5种解决方案

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 能够防止加锁排队执行的问题。

关注公号「Java 中文社群」查看更多有意思、涨常识的并发编程文章。