时间工具类--解决simpleDateFormat线程不安全问题---使用threadLocal

最新推荐文章于 2021-07-09 14:59:37 发布
最新推荐文章于 2021-07-09 14:59:37 发布
阅读量969 收藏
点赞数
分类专栏： 工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41325595/article/details/90239341
版权 
public class DateUtil {
    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    public static final String SLASH_DATE_FORMAT = "yyyy/MM/dd";
    public static final String NOT_SLASH_DATE_FORMAT = "yyyyMMdd";
    public static final String CN_DATE_FORMAT = "yyyy'年'MM'月'dd'日'";
    public static final String MONTH_DAY_YEAR_FORMAT = "M/d/yyyy";
    public static final String DEFAULT_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String SLASH_DATETIME_FORMAT = "yyyy/MM/dd HH:mm:ss";
    public static final String NOT_SLASH_DATETIME_FORMAT = "yyyyMMdd HH:mm:ss";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
    private static final ThreadLocal<SimpleDateFormat> DEFAULT_DATE_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };
    private static final ThreadLocal<SimpleDateFormat> SLASH_DATE_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy/MM/dd");
        }
    };
    private static final ThreadLocal<SimpleDateFormat> NOT_SLASH_DATE_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyyMMdd");
        }
    };
    private static final ThreadLocal<SimpleDateFormat> CN_DATE_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy'年'MM'月'dd'日'");
        }
    };
    private static final ThreadLocal<SimpleDateFormat> MONTH_DAY_YEAR_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("M/d/yyyy");
        }
    };
    private static final ThreadLocal<SimpleDateFormat> DEFAULT_DATETIME_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };
    private static final ThreadLocal<SimpleDateFormat> SLASH_DATETIME_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        }
    };
    private static final ThreadLocal<SimpleDateFormat> NOT_SLASH_DATETIME_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyyMMdd HH:mm:ss");
        }
    };
    private static final ThreadLocal<SimpleDateFormat> DEFAULT_TIME_FORMATTER = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected synchronized SimpleDateFormat initialValue() {
            return new SimpleDateFormat("HH:mm:ss");
        }
    };

    public DateUtil() {
    }

    public static final Date getCurrentDate() {
        return (new DateTime()).toDate();
    }

    public static final String getCurrentDefaultDateString() {
        return (new DateTime()).toString("yyyy-MM-dd");
    }

    public static final String getCurrentNotSlashDateString() {
        return (new DateTime()).toString("yyyyMMdd");
    }

    public static final String getCurrentDateTimeString() {
        return (new DateTime()).toString("yyyy-MM-dd HH:mm:ss");
    }

    public static final String getCurrentTimeString() {
        return (new DateTime()).toString("HH:mm:ss");
    }

    public static final Calendar getCurrentCalendar() {
        return Calendar.getInstance();
    }

    public static final Calendar getCalendar(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar;
    }

    public static final Calendar getCalendar(String date) throws ParseException {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(parseDate(date));
        return calendar;
    }

    public static final Calendar getCalendar(String date, String pattern) throws ParseException {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(parseDate(date, pattern));
        return calendar;
    }

    public static final Date makeDate(int year, int month, int day) {
        return (new LocalDate(year, month, day)).toDate();
    }

    public static final Date makeDateTime(int year, int month, int day, int hour, int minute, int second) {
        return (new DateTime(year, month, day, hour, minute, second, 0)).toDate();
    }

    public static final Date parseDate(String date) {
        DateFormat[] formatters = new DateFormat[]{(DateFormat)DEFAULT_DATETIME_FORMATTER.get(), (DateFormat)SLASH_DATETIME_FORMATTER.get(), (DateFormat)NOT_SLASH_DATETIME_FORMATTER.get(), (DateFormat)DEFAULT_TIME_FORMATTER.get(), (DateFormat)DEFAULT_DATE_FORMATTER.get(), (DateFormat)SLASH_DATE_FORMATTER.get(), (DateFormat)NOT_SLASH_DATE_FORMATTER.get(), (DateFormat)CN_DATE_FORMATTER.get(), (DateFormat)MONTH_DAY_YEAR_FORMATTER.get()};
        DateFormat[] var2 = formatters;
        int var3 = formatters.length;
        int var4 = 0;

        while(var4 < var3) {
            DateFormat formatter = var2[var4];

            try {
                return formatter.parse(date);
            } catch (ParseException var7) {
                ++var4;
            }
        }

        return null;
    }

    public static final <T extends Date> Date parseDate(String date, Class<T> clz) throws ParseException, InstantiationException, IllegalAccessException {
        Date t = (Date)clz.newInstance();
        t.setTime(parseDate(date).getTime());
        return t;
    }

    public static final Date parseDate(String date, String pattern) throws ParseException {
        DateFormat dateFormat = new SimpleDateFormat(pattern);
        return dateFormat.parse(date);
    }

    public static final String formatDate(Date date) {
        return (new DateTime(date)).toString("yyyy-MM-dd");
    }

    public static final String formatDateTime(Date date) {
        return (new DateTime(date)).toString("yyyy-MM-dd HH:mm:ss");
    }

    public static final String formatTime(Date date) {
        return (new DateTime(date)).toString("HH:mm:ss");
    }

    public static final String formatDate(Date date, String pattern) {
        return (new DateTime(date)).toString(pattern);
    }

    public static final int getYearsBetween(Date a, Date b) {
        return Years.yearsBetween(toJodaDateTime(a), toJodaDateTime(b)).getYears();
    }

    public static final int getYearsBetween(String a, String b) throws ParseException {
        return Years.yearsBetween(toJodaDateTime(a), toJodaDateTime(b)).getYears();
    }

    public static final int getMonthsBetween(Date a, Date b) {
        return Months.monthsBetween(toJodaDateTime(a), toJodaDateTime(b)).getMonths();
    }

    public static final int getMonthsBetween(String a, String b) throws ParseException {
        return Months.monthsBetween(toJodaDateTime(a), toJodaDateTime(b)).getMonths();
    }

    public static final int getDaysBetween(Date a, Date b) {
        return Days.daysBetween(toJodaDateTime(a), toJodaDateTime(b)).getDays();
    }

    public static final int getDaysBetween(String a, String b) throws ParseException {
        return Days.daysBetween(toJodaDateTime(a), toJodaDateTime(b)).getDays();
    }

    public static final int getHoursBetween(Date a, Date b) {
        return Hours.hoursBetween(toJodaDateTime(a), toJodaDateTime(b)).getHours();
    }

    public static final int getHoursBetween(String a, String b) throws ParseException {
        return Hours.hoursBetween(toJodaDateTime(a), toJodaDateTime(b)).getHours();
    }

    public static final int getMinutesBetween(Date a, Date b) {
        return Minutes.minutesBetween(toJodaDateTime(a), toJodaDateTime(b)).getMinutes();
    }

    public static final int getMinutesBetween(String a, String b) throws ParseException {
        return Minutes.minutesBetween(toJodaDateTime(a), toJodaDateTime(b)).getMinutes();
    }

    public static final int getSecondsBetween(Date a, Date b) {
        return Seconds.secondsBetween(toJodaDateTime(a), toJodaDateTime(b)).getSeconds();
    }

    public static final int getSecondsBetween(String a, String b) throws ParseException {
        return Seconds.secondsBetween(toJodaDateTime(a), toJodaDateTime(b)).getSeconds();
    }

    public static final DateTime toJodaDateTime(Date date) {
        return new DateTime(date);
    }

    public static final DateTime toJodaDateTime(String date) throws ParseException {
        return toJodaDateTime(parseDate(date));
    }

    public static final Date plusYears(Date date, int years) {
        return toJodaDateTime(date).plusYears(years).toDate();
    }

    public static final Date plusYears(String date, int years) throws ParseException {
        return toJodaDateTime(date).plusYears(years).toDate();
    }

    public static final Date plusMonths(Date date, int months) {
        return toJodaDateTime(date).plusMonths(months).toDate();
    }

    public static final Date plusMonths(String date, int months) throws ParseException {
        return toJodaDateTime(date).plusMonths(months).toDate();
    }

    public static final Date plusDays(Date date, int days) {
        return toJodaDateTime(date).plusDays(days).toDate();
    }

    public static final Date plusDays(String date, int days) throws ParseException {
        return toJodaDateTime(date).plusDays(days).toDate();
    }

    public static final Date plusHours(Date date, int hours) {
        return toJodaDateTime(date).plusHours(hours).toDate();
    }

    public static final Date plusHours(String date, int hours) throws ParseException {
        return toJodaDateTime(date).plusHours(hours).toDate();
    }

    public static final Date plusMinutes(Date date, int minutes) {
        return toJodaDateTime(date).plusMinutes(minutes).toDate();
    }

    public static final Date plusMinutes(String date, int minutes) throws ParseException {
        return toJodaDateTime(date).plusMinutes(minutes).toDate();
    }

    public static final Date plusSeconds(Date date, int seconds) {
        return toJodaDateTime(date).plusSeconds(seconds).toDate();
    }

    public static final Date plusSeconds(String date, int seconds) throws ParseException {
        return toJodaDateTime(date).plusSeconds(seconds).toDate();
    }

    public static final boolean isBetween(Date a, Date b, Date date) {
        if (a != null && b != null && date != null) {
            Interval interval = new Interval(toJodaDateTime(a), toJodaDateTime(b));
            return interval.contains(date.getTime()) || date.equals(b);
        } else {
            return false;
        }
    }

    public static final boolean isBetween(String a, String b, String date) throws ParseException {
        if (a != null && b != null && date != null) {
            Interval interval = new Interval(toJodaDateTime(a), toJodaDateTime(b));
            return interval.contains(toJodaDateTime(date)) || date.equals(b);
        } else {
            return false;
        }
    }

    public static final long getMillisBetween(Date a, Date b) {
        return (new Duration(toJodaDateTime(a), toJodaDateTime(b))).getMillis();
    }

    public static final long getMillisBetween(String a, String b) throws ParseException {
        return (new Duration(toJodaDateTime(a), toJodaDateTime(b))).getMillis();
    }

    public static final Date getLater(Date a, Date b) {
        if (a.equals(b)) {
            return null;
        } else {
            return a.after(b) ? a : b;
        }
    }

    public static final Date getEarlier(Date a, Date b) {
        if (a.equals(b)) {
            return null;
        } else {
            return a.before(b) ? a : b;
        }
    }

    public static final Date getFirstDayOfMonth(Date date) {
        return toJodaDateTime(date).dayOfMonth().withMinimumValue().toDate();
    }

    public static final Date getLastDayOfMonth(Date date) {
        return toJodaDateTime(date).dayOfMonth().withMaximumValue().toDate();
    }

    public static final int getYear(Date date) {
        return toJodaDateTime(date).getYear();
    }

    public static final int getYear(String date) throws ParseException {
        return toJodaDateTime(date).getYear();
    }

    public static final int getMonth(Date date) {
        return toJodaDateTime(date).getMonthOfYear();
    }

    public static final int getMonth(String date) throws ParseException {
        return toJodaDateTime(date).getMonthOfYear();
    }

    public static final int getDayOfWeek(Date date) {
        return toJodaDateTime(date).getDayOfWeek();
    }

    public static final int getDayOfWeek(String date) throws ParseException {
        return toJodaDateTime(date).getDayOfWeek();
    }

    public static final int getDay(Date date) {
        return toJodaDateTime(date).getDayOfMonth();
    }

    public static final int getDay(String date) throws ParseException {
        return toJodaDateTime(date).getDayOfMonth();
    }

    public static final int getHour(Date date) {
        return toJodaDateTime(date).getHourOfDay();
    }

    public static final int getHour(String date) throws ParseException {
        return toJodaDateTime(date).getHourOfDay();
    }

    public static final int getMinute(Date date) {
        return toJodaDateTime(date).getMinuteOfHour();
    }

    public static final int getMinute(String date) throws ParseException {
        return toJodaDateTime(date).getMinuteOfHour();
    }

    public static final int getSecond(Date date) {
        return toJodaDateTime(date).getSecondOfMinute();
    }

    public static final int getSecond(String date) throws ParseException {
        return toJodaDateTime(date).getSecondOfMinute();
    }

   /* public static int age(Date birthDay, Date dateToCompare) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(dateToCompare);
        if (cal.before(birthDay)) {
            throw new IllegalArgumentException(StrUtil.format("Birthday is after date {}!", new Object[]{formatDate(dateToCompare)}));
        } else {
            int year = cal.get(1);
            int month = cal.get(2);
            int dayOfMonth = cal.get(5);
            cal.setTime(birthDay);
            int age = year - cal.get(1);
            int monthBirth = cal.get(2);
            if (month == monthBirth) {
                int dayOfMonthBirth = cal.get(5);
                if (dayOfMonth < dayOfMonthBirth) {
                    --age;
                }
            } else if (month < monthBirth) {
                --age;
            }

            return age;
        }
    }*/

    public static List<String> getWeekly(int intervals) {
        List<String> pastDaysList = new ArrayList();

        for(int i = 1; i < intervals; ++i) {
            pastDaysList.add(getPastDate(i));
        }

        return pastDaysList;
    }

    public static String getPastDate(int past) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(6, calendar.get(6) - past);
        Date today = calendar.getTime();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String result = format.format(today);
        return result;
    }

    public static int getWeeksfrom1970() {
        int days = getDaysBetween(parseDate("1970-01-01 00:00:00"), new Date());
        days += 3;
        return days / 7;
    }

    public static void main(String[] args) throws ParseException, InstantiationException, IllegalAccessException {
    }

    static {
        ((SimpleDateFormat)DEFAULT_DATE_FORMATTER.get()).setLenient(false);
        ((SimpleDateFormat)SLASH_DATE_FORMATTER.get()).setLenient(false);
        ((SimpleDateFormat)NOT_SLASH_DATE_FORMATTER.get()).setLenient(false);
        ((SimpleDateFormat)CN_DATE_FORMATTER.get()).setLenient(false);
        ((SimpleDateFormat)MONTH_DAY_YEAR_FORMATTER.get()).setLenient(false);
        ((SimpleDateFormat)DEFAULT_DATETIME_FORMATTER.get()).setLenient(false);
        ((SimpleDateFormat)SLASH_DATETIME_FORMATTER.get()).setLenient(false);
        ((SimpleDateFormat)NOT_SLASH_DATETIME_FORMATTER.get()).setLenient(false);
        ((SimpleDateFormat)DEFAULT_TIME_FORMATTER.get()).setLenient(false);
    }
}

 

旧人可安
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
为什么SimpleDateFormat要放到ThreadLocal里？
王忠的博客
08-03 1320
这两天工作中看到有人把SimpleDateFormat对象放在了ThreadLocal里，当时有点疑惑，ThreadLocal的主要作用肯定是用来做线程隔离的，那么为什么SimpleDateFormat这种简单的时间格式转换工具也要做线程隔离呢？ 查阅了一些博客，翻看了源码，搞懂了。 记录一下，以便回顾。 SimpleDateFormat是线程不安全的，我们直接上代码。 一般来说，这种时间格式转换工具，我们都会做成一个公共工具类，如下所示： public class DateUtil {
详解SimpleDateFormat的线程安全问题与解决方案
08-30
在Java编程中，`SimpleDateFormat`是一个常用的日期时间格式化工具类，但它的设计并不是线程安全的。本文将深入探讨`SimpleDateFormat`的线程安全问题及其解决方案。 ### 1. 线程安全问题的原因 `SimpleDateFormat...
SimpleDateFormat线程不安全问题与ThreadLocal原理
lvlei19911108的博客
07-01 176
SimpleDateFormat是JDK中长久以来自带的日期时间格式化类，但是它有线程安全性方面的问题，使用时要避免它带来的影响。 SimpleDateFormat是线程不安全的 写一个SimpleDateFormat在并发环境下简单的例子先。 public class SimpleDateFormatExample { private static SimpleDateFormat si...
ThreadLocal类与SimpleDateFormat类
Megustas_JJC的博客
11-12 654
ThreadLocal类维持线程封闭性,可以使线程中的某个值与保存值得对象关联起来。为每个使用该变量的线程都存有一份独立的脚本，因此get总是返回当前执行线程在调用set时设置的最新值。 ThreadLocal对象通常用于防止对可变的单实例变量（Singleton）或全局变量进行共享（在多线程应用程序在没有协同的情况下使用全局变量时，就不是线程安全的） 深入理解Java：SimpleDateFor...
基于ThreadLocal的日期工具类
YLG_1300710336的博客
09-02 1218
&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;有时候我们会使用到JDK java.text.*下的SimpleDateFormat类来对我们的日期与字符串进行格式化得转换，此时我们很容易想到，要基于 SimpleDateFormat封装成一个工具类，笔者一开始的代码类似下面： package com.zhegui.utils.date; import
Java ThreadLocal 线程安全问题解决方案
09-01
Java中的ThreadLocal是解决线程安全问题的一个重要工具，它提供了一种在多线程环境下为每个线程维护独立变量副本的方法，从而避免了共享状态带来的竞态条件和线程安全问题。 线程安全问题通常由全局变量和静态变量...
Java SimpleDateFormat线程安全问题原理详解
08-19
Java SimpleDateFormat线程安全问题原理详解 Java SimpleDateFormat线程安全问题是Java开发中一个常见的问题...通过使用ThreadLocal或FastDateFormat，我们可以解决这个问题，确保日期时间格式化结果正确且线程安全。
simpleDateFormat是线程不安全的
03-19
在Java编程语言中，`SimpleDateFormat`类是一个广泛使用的日期时间格式化工具，但它的线程安全性是一个常常被开发者忽视的问题。标题指出的"simpleDateFormat是线程不安全的"，意味着在多线程环境下，如果多个线程...
关于SimpleDateFormat的非线程安全问题及其解决方案.docx
10-26
3. **使用不可变的日期时间API**：从Java 8开始，提供了新的日期时间API（如`java.time`包下的类），这些API设计为线程安全的，可以替代`SimpleDateFormat`。 ```java import java.time.LocalDate; import java....
Threadlocal做SimpleDateFormat
huiyanshizhen21的博客
04-25 2412
1.Threadlocal 当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。 2.demo package com.yinzhen.demo.thread; import java.text.SimpleDateFormat; import java.util.Dat...
【并发编程】ThreadLocal：如何优雅的解决SimpleDateFormat多线程安全问题
流星007
03-31 2836
还在为SimpleDateFormat在多线程中存在的安全问题吗？这篇文章将会以最优雅的方式解决SimpleDateFormat在多线程中的问题，那就是：ThreadLocal（本地线程存储）
ThreadLocal封装SimpleDateFormat
Leon_Jinhai_Sun的博客
11-09 563
调用Thread.currentThread()获取当前线程。 JDK提供了ThreadLocal，在一个线程中传递同一个对象。 ThreadLocal表示线程的“局部变量”，它确保每个线程的ThreadLocal变量都是各自独立的。 ThreadLocal适合在一个线程的处理流程中保持上下文（避免了同一参数在所有方法中传递） 使用ThreadLocal要用try … finally结构。 p...
ThreadLocal实现线程安全的时间格式化SimpleDateFormat
长寿仙人的专栏
03-16 554
import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.Map; /** * 时间格式化工具 * * @author sunweidong */ public class SimpleDateFormatUtil { /** 同步锁 */ private static final Object syncLock = new Objec.
jdk- 线程不安全的 SimpleDateFormat
qbian的博客
08-29 359
一 测试 demo 我们先来写一个测试 demo public class SimpleDateFormatTest { private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); static class ParseDate implements Runn...
ThreadLocal 实现的线程安全SimpleDateFormat
zhaozhen1990的博客
01-09 450
public class SafeSimpleDateFormat { private final String _format; private static final ThreadLocal> _dateFormats = new ThreadLocal>() { public Map initialValue() {
ThreadLocal＜SimpleDateFormat＞使用
不积硅步无以至千里
07-09 791
问题 SimpleDateFormat(下面简称sdf)类内部有一个Calendar对象引用,它用来储存和这个sdf相关的日期信息,例如sdf.parse(dateStr), sdf.format(date) 诸如此类的方法参数传入的日期相关String, Date等等, 都是由Calendar来储存的. 如果你的sdf是个static的, 那么多个thread 之间就会共享这个sdf, 同时也是共享这个Calendar引用,对这个Calendar同时操作就会导致读写不...
ThreadLocal解决SimpleDateFormat线程安全问题
jike11231的博客
09-11 3216
ThreadLocal的应用场景之一就是可以解决SimpleDateFormat线程安全问题。 一、SimpleDateFormat线程不安全原因 SimpleDateFormat(下面简称sdf)类内部有一个Calendar对象引用，它用来储存和这个sdf相关的日期信息，例如sdf.parse(dateStr)， sdf.format(date)诸如此类的方法参数传入的日期相关String，Date等等，都是交友Calendar引用来储存的。这样就会导致一个问题，如果你的sdf是个static的，那么多个
Java深入：SimpleDateFormat的线程安全与高效使用
"本文主要探讨了Java中的SimpleDateFormat类，关注其在时间格式化过程中的安全性问题，并提供了关于如何在多线程环境中正确使用的建议。文章指出，由于SimpleDateFormat不是线程安全的，因此在并发情况下需要采取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值