SimpleDateFormat的线程安全性问题

问题：

public class Test {
    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    private static class Task implements Runnable {

        public void run() {
            try {
                System.out.println(sdf.parse("2016-03-21 12:00:00").getTime());
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Task task = new Task();

        Thread t1 = new Thread(task);
        t1.start();
        Thread t2 = new Thread(task);
        t2.start();
        Thread t3 = new Thread(task);
        t3.start();
        Thread t4 = new Thread(task);
        t4.start();
        Thread t5 = new Thread(task);
        t5.start();
    }
}

平时经常都会用到SimpleDateFormat来对日期字符串进行解析和格式化。而且一般都是创建一个Util工具类，然后定义一个静态的SimpleDateFormat实例变量。需要格式化时就直接使用这个变量进行操作。

在大多数正常的测试情况之下，出来的结果都是没问题的。然而，我最近在看《Java并发编程实践》的过程中才发现这样做并不是线程安全的，当在并发量较高的生产环境中，问题就出现了，会出现各种不同的错误，例如线程被挂死，转换的时间不正确。

下图的输出结果是线程被挂死了：

image

下图是转换的时间不对：

image

原因

以前之所以忽略这个问题，一来对多线程没有很深入的理解；二是因为从这个类中完全看不出与线程安全有什么关系，因为SimpleDateFormat 实例变量已经是用final 修饰了，就一直以为是状态不变的了。

而在jdk的官方文档里面，也有提到

" 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."

就是说。Date formats不是同步的，建议每个线程都分别创建format实例变量；或者如果多个线共享一个format的话，必须保持在使用format时是同步的

而从源码入手分析原因，会发现在SimpleDateFormat类的parse()方法有这么一段注释

 This parsing operation uses the DateFormat#calendar
 to produce a Date. All of the
 calendar's date-time fields are Calendar#clear()
 cleared before parsing, and the calendar's default
 values of the date-time fields are used for any missing
 date-time information.

大概意思就是parse()方法使用calendar来生成返回的Date实例，而每次parse之前，都会先把calendar里的相关属性清除掉。
问题是这个calendar是个全局变量，也就是线程共享的。因此就会出现一个线程刚把calendar设置好，另一个线程把它给清空了，
这时第一个线程再parse的话就会有问题了。

解决方案

需要的时候创建局部变量

public Date formatDate(Date d) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    return sdf.parse(d);
}

创建一个共享的SimpleDateFormat实例变量，但是在使用的时候，需要对这个变量进行同步

private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
public Date formatDate(Date d) {
    synchronized(sdf) {
        return sdf.parse(d);
    }
}

使用ThreadLocal为每个线程都创建一个线程独享SimpleDateFormat变量

private ThreadLocal tl = new ThreadLocal();
public Date formatDate(Date d) {
    SimpleDateFormat sdf = tl.get();
    if(sdf == null) {
        sdf = new SimpleDateFormat("yyyy-MM-dd");
        tl.set(sdf);
    }
    return sdf.parse(d);
}

性能对比

分别测试了一下上面三种方案，每种方案分别开了10000线程去进行时间格式化，记录下消耗的时间。测试代码如下：

public class Test {

    private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    /**
     * Option 1: Create local instances when required
     */
    public static Date parse1(String dateStr) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return sdf.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Option 2: Create an instance of SimpleDateFormat as a class variable but synchronize access to it.
     */
    public static Date parse2(String dateStr) {
        synchronized (sdf) {
            try {
                return sdf.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * Option 3: Create a ThreadLocal to store a different instance of SimpleDateFormat for each thread.
     */
    private static ThreadLocal tl = new ThreadLocal();

    public static Date parse3(String dateStr) {
        SimpleDateFormat sdf = tl.get();
        if (sdf == null) {
            sdf = new SimpleDateFormat("yyyy-MM-hh");
            tl.set(sdf);
        }
        try {
            return sdf.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    private static class Task implements Callable {
        public Date call() throws Exception {
            return parse1("2016-03-21 12:00:00");
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(50);
        List> resultList = new ArrayList>();

        long s = System.currentTimeMillis();
        //创建10000个任务并执行
        for (int i = 0; i < 10000; i++) {
            //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
            Future future = executorService.submit(new Task());
            //将任务执行结果存储到List中
            resultList.add(future);
        }

        //遍历任务的结果
        for (Future fs : resultList) {
            try {
                while (!fs.isDone())
                    ;//Future返回如果没有完成，则一直循环等待，直到Future返回完成
                System.out.println(fs.get().getTime());     //打印各个线程（任务）执行的结果
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            } finally {
                //启动一次顺序关闭，执行以前提交的任务，但不接受新任务
                executorService.shutdown();
            }
        }
        long e = System.currentTimeMillis();

        System.out.println("time elapse: " + (e - s));
    }
}

对于每种方案，我各执行了12次，然后去掉一个最高消耗，一个最低消耗，剩下的取平均值。测试结果如下：

方案1： 平均 410ms  

方案2： 平均 217ms 

方案3： 平均 300ms 

从结果看出，方案1性能最差，因为每次都需要new一个format实例。不推荐使用

方案2虽然看起来最优，但线程越来越多时，因为使用了同步块，当一个线程调用format的方法时，其余线程就会阻塞，性能会优一定影响。

方案3，每个线程维护一个format实例，50个线程就有50个实例，对内存占用的消耗会比方案2要大，当影响不会太大，网上说法是：
对性能要求比较高的情况下，一般推荐使用这种方法

综上所述，方案2和方案3都可以，至于具体使用哪一种，具体情况而定