多线程SimpleDateFormat日期格式化与ThreadLocal用法

SimpleDateFormat 是 JDK 提供的一个日期格式化和解析类，但它是非线程安全的，原因如下。

parse方法

        Date parsedDate;
        try {
            parsedDate = calb.establish(calendar).getTime();
            // If the year value is ambiguous,
            // then the two-digit year == the default start year
            if (ambiguousYear[0]) {
                if (parsedDate.before(defaultCenturyStart)) {
                    parsedDate = calb.addYear(100).establish(calendar).getTime();
                }
            }
        }
        // An IllegalArgumentException will be thrown by Calendar.getTime()
        // if any fields are out of range, e.g., MONTH == 17.
        catch (IllegalArgumentException e) {
            pos.errorIndex = start;
            pos.index = oldStart;
            return null;
        }

其中，calb.establish(calendar)初始化了calendar日历数据

跟进查看

        //1-----------------------
        cal.clear();
        // Set the fields from the min stamp to the max stamp so that
        // the field resolution works in the Calendar.
        for (int stamp = MINIMUM_USER_STAMP; stamp < nextStamp; stamp++) {
            for (int index = 0; index <= maxFieldIndex; index++) {
                if (field[index] == stamp) {
                    cal.set(index, field[MAX_FIELD + index]);//2--------------
                    break;
                }
            }
        }

        if (weekDate) {
            int weekOfYear = isSet(WEEK_OF_YEAR) ? field[MAX_FIELD + WEEK_OF_YEAR] : 1;
            int dayOfWeek = isSet(DAY_OF_WEEK) ?
                                field[MAX_FIELD + DAY_OF_WEEK] : cal.getFirstDayOfWeek();
            if (!isValidDayOfWeek(dayOfWeek) && cal.isLenient()) {
                if (dayOfWeek >= 8) {
                    dayOfWeek--;
                    weekOfYear += dayOfWeek / 7;
                    dayOfWeek = (dayOfWeek % 7) + 1;
                } else {
                    while (dayOfWeek <= 0) {
                        dayOfWeek += 7;
                        weekOfYear--;
                    }
                }
                dayOfWeek = toCalendarDayOfWeek(dayOfWeek);
            }
            cal.setWeekDate(field[MAX_FIELD + WEEK_YEAR], weekOfYear, dayOfWeek);//2-----------
        }

        //3-------------------
        return cal;

参考1- 2- 3-注释，线程不安全的原因，不能保证多核模式下，多线程执行是顺序执行的原子性

解决方法

1. 加锁

自建方法包裹代码

public class SimpleDateFormatTest {

    
    static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static synchronized Date parse(String s) throws ParseException {
        return sdf.parse(s);
    }

    public static void main(String[] args) {
        
        for (int i = 0; i <20 ; ++i) {
            Thread thread = new Thread(() -> {
                public void run() {
                    try {
                        
                            System.out.println(parse("2018-07-17 10:52:16"));
                        
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                }
            };
            thread.start()
        }
    }

}

串行执行，在大批量调用效率很低，不推荐

2.每次调用创建一个对象

    public Date parse(String s) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.parse(s);
    }

缺点，耗内存，GC压力增大，每次创建对象销毁，分配和销毁内存空间，整理内存，GC。不推荐

3.每个线程创建一个对象

public class SimpleDateFormatTest {
    
    static ThreadLocal<SimpleDateFormat> local= new ThreadLocal<SimpleDateFormat>(){
        @Override
        protected SimpleDateFormat initialValue(){
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };

    public static void main(String[] args) {
        
        for (int i = 0; i < 5; ++i) {
            Thread thread = new Thread(() -> {
                public void run() {
                    try {
                        System.out.println(local.get().parse("2018-07-17 11:01:16"));
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }finally {
                        //TODO 线程运行结束清除，避免内存泄露
                        local.remove();
                    }
                }
            });

            thread.start();
        }
    }

}

每个线程一个对象，提高format对象利用率，推荐使用

但是ThreadLocal的存储是自定义map，key是线程相关弱引用，随线程结束而结束，value是我们创建的对象是强引用，需要每次结束后remove()显示调用，set()方法也可以