SimpleDateFormat类线程不安全及解决方案

最新推荐文章于 2024-07-20 13:08:48 发布
最新推荐文章于 2024-07-20 13:08:48 发布
阅读量298 收藏
点赞数
分类专栏： java面试 高并发 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36594703/article/details/117957385
版权 
public class SimpleDateFormatTest01 {
    private static final int EXECUTE_COUNT = 1000;
    private static final int THREAD_COUNT = 20;
//    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
//    private static Lock lock = new ReentrantLock();
//    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
//        @Override
//        protected DateFormat initialValue(){
//            return new SimpleDateFormat("yyyy-MM-dd");
//        }
//    };
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                        simpleDateFormat.parse("2020-01-01");
                    } catch (ParseException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    } catch (NumberFormatException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

解决线程安全问题：

1.局部变量法：

public class SimpleDateFormatTest01 {
    private static final int EXECUTE_COUNT = 1000;
    private static final int THREAD_COUNT = 20;
//    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
//    private static Lock lock = new ReentrantLock();
//    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
//        @Override
//        protected DateFormat initialValue(){
//            return new SimpleDateFormat("yyyy-MM-dd");
//        }
//    };
    //private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                        simpleDateFormat.parse("2020-01-01");
                    } catch (ParseException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    } catch (NumberFormatException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

 2.Synchronized锁方式：

public class SimpleDateFormatTest01 {
    private static final int EXECUTE_COUNT = 1000;
    private static final int THREAD_COUNT = 20;
//    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
//    private static Lock lock = new ReentrantLock();
//    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
//        @Override
//        protected DateFormat initialValue(){
//            return new SimpleDateFormat("yyyy-MM-dd");
//        }
//    };
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                        synchronized (simpleDateFormat) {
                            simpleDateFormat.parse("2020-01-01");
                        }
                    } catch (ParseException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    } catch (NumberFormatException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

3.Lock锁方式：

public class SimpleDateFormatTest01 {
    private static final int EXECUTE_COUNT = 1000;
    private static final int THREAD_COUNT = 20;
//    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
//    private static Lock lock = new ReentrantLock();
//    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
//        @Override
//        protected DateFormat initialValue(){
//            return new SimpleDateFormat("yyyy-MM-dd");
//        }
//    };
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    private static Lock lock = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                        lock.lock();
                        simpleDateFormat.parse("2020-01-01");

                    } catch (ParseException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    } catch (NumberFormatException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    }finally {
                        lock.unlock();
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

4.ThreadLocal方式：

public class SimpleDateFormatTest01 {
    private static final int EXECUTE_COUNT = 1000;
    private static final int THREAD_COUNT = 20;
//    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
//    private static Lock lock = new ReentrantLock();
    private static ThreadLocal<DateFormat> threadLocal = new ThreadLocal<DateFormat>(){
        @Override
        protected DateFormat initialValue(){
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };
    private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    public static void main(String[] args) throws InterruptedException {
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < EXECUTE_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    try {
                        threadLocal.get().parse("2020-01-01");

                    } catch (ParseException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    } catch (NumberFormatException e) {
                        System.out.println("线程：" + Thread.currentThread().getName() + " 格式化日期失 败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    semaphore.release();
                } catch (InterruptedException e) {
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

5.DateTimeFormatter方式：
DateTimeFormatter是Java8提供的新的日期时间API的类，DateTimeFormatter类是线程安全的，可以再高并发场景下直接使用。

public class DateTimeFormatterTest {
    // 执行总次数
    private static final int EXECUTE_COUNT = 1000;
    // 同时运行的线程数量
    private static final int THREAD_COUNT = 20;
    private static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    public static void main(String[] args) throws Exception{
        final Semaphore semaphore = new Semaphore(THREAD_COUNT);
        final CountDownLatch countDownLatch = new CountDownLatch(EXECUTE_COUNT);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i = 0; i < EXECUTE_COUNT; i++){
            executorService.execute(()->{
                try{
                    semaphore.acquire();
                    try{
                        LocalDate.parse("2020-01-01",formatter);
                    }catch (Exception e){
                        System.out.println("线程："+Thread.currentThread().getName()+"日期转换失败");
                        e.printStackTrace();
                        System.exit(1);
                    }
                    semaphore.release();
                }catch (InterruptedException e){
                    System.out.println("信号量发生错误");
                    e.printStackTrace();
                    System.exit(1);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("所有线程格式化日期成功");
    }
}

 

qq_36594703
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA干货|让我告诉你SimpleDateFormat线程不安全的5种解决方案！
m0_57227221的博客
05-17 686
1.什么是线程不安全？ 线程不安全也叫非线程安全，是指多线程执行中，程序的执行结果和预期的结果不符的情况就叫做线程不安全。 ​ 线程不安全的代码 SimpleDateFormat 就是一个典型的线程不安全事例，接下来我们动手来实现一下。首先我们先创建 10 个线程来格式化时间，时间格式化每次传递的待格式化时间都是不同的，所以程序如果正确执行将会打印 10 个不同的值，接下来我们来看具体的代码实现： import java.text.SimpleDateFormat; import java.util.Da.
SimpleDateFormat线程不安全的原因以及解决方案
m0_37822338的博客
08-21 516
阿里巴巴java开发手册强制要求： 5. 【强制】SimpleDateFormat 是线程不安全的类，一般不要定义为 static 变量，如果定义为 static，必须加锁，或者使用 DateUtils 工具类。（org.apache.commons.lang3.time.DateUtils） 因为SimpleDateFormat 继承DateFormat，DateFormat中定义了属性ca...
SimpleDateFormat线程不安全及解决办法
热门推荐
技术人生
11-12 1万+
一. 为什么SimpleDateFormat不是线程安全的？ Java源码如下：
java的SimpleDateFormat线程不安全出问题了，虚竹教你多种解决方案_simpledateformat 漏洞
最新发布
2401_84264536的博客
07-20 760
就是要使用SimpleDateFormat对象进行format或parse时，再定义为局部变量。就能保证线程安全。//1、创建线程池//2、为线程池分配任务i < 10;i++) {//3、关闭线程池@Overridetry {System.out.println(Thread.currentThread().getName()+" 线程是否安全: "+dateString.equals(dateString2));
SimpleDateFormat线程不安全
RyanDon的博客
03-25 1161
遇到的问题： 项目中设置了静态全局的SimpleDateFormat时间转换的格式，线上在并发使用的时候，出现了时间数据转换混乱的情况 原因： SimpleDateFormat中，SimpleDateFormat类中定义的Calendar是共享的，并发设值的时候承载的对象可能会被替换，造成转换的数据混乱，如下图所示 解决方法： 试过使用ThreadLocal去构造SimpleDateFormat对象还是没能解决，最终使用了线程安全的DateTimeFormatter进行替换 DateTim.
详解SimpleDateFormat的线程安全问题与解决方案
08-30
本文将深入探讨`SimpleDateFormat`的线程安全问题及其解决方案。 ### 1. 线程安全问题的原因 `SimpleDateFormat`内部维护了一个`Calendar`对象，用于处理日期和时间的解析与格式化。由于`SimpleDateFormat`不是...
高并发之-SimpleDateFormat类的线程安全问题和解决方案.docx
10-26
SimpleDateFormat类的线程安全问题和解决方案 SimpleDateFormat类的线程安全问题 SimpleDateFormat类是Java提供的日期时间转化类，用于将日期和时间类型的数据进行解析和格式化。在Java开发中，SimpleDateFormat类...
simpleDateFormat是线程不安全的
03-19
分析这个文件可以帮助我们更好地理解线程安全问题的实际表现和解决方案。 总的来说，理解`SimpleDateFormat`的线程不安全性质是Java开发中的一项重要知识，特别是在设计高并发系统时。开发者应当根据具体需求选择...
SimpleDateFormat线程不安全的5种解决方案.docx
10-26
nable() { @Override public void run() { // 定义局部变量 SimpleDateFormat SimpleDateFormat simpleDateFormat = new ...根据实际应用场景，可以选择适合的解决方案以确保线程安全并提高程序的并发性能。
simpleDateFormat线程不安全
weixin_33717117的博客
12-04 135
simpleDateFormat是我们比较常用的日期转换类，但是它...
为什么SimpleDateFormat不是线程安全的？
niceyoo的博客
09-15 632
一、前言 日期的转换与格式化在项目中应该是比较常用的了，最近同事小刚出去面试实在是没想到被 SimpleDateFormat 给摆了一道… 面试官：项目中的日期转换怎么用的？SimpleDateFormat 用过吗？能说一下 SimpleDateFormat 线程安全问题吗，以及如何解决？ 同事小刚：用过的，平时就是在全局定义一个 static 的 SimpleDateFormat，然后在业务处理方法（controller）中直接使用，至于线程安全… 这个… 倒是没遇到过线程安全问题。 哎，面试官的考察点真
SimpleDateFormat线程不安全的5种解决方案！
weixin_48967543的博客
05-17 407
1.什么是线程不安全？领券 https://m.cps3.cn/ 线程不安全也叫非线程安全，是指多线程执行中，程序的执行结果和预期的结果不符的情况就叫做线程不安全。 ​ 线程不安全的代码 SimpleDateFormat 就是一个典型的线程不安全事例，接下来我们动手来实现一下。首先我们先创建 10 个线程来格式化时间，时间格式化每次传递的待格式化时间都是不同的，所以程序如果正确执行将会打印 10 个不同的值，接下来我们来看具体的代码实现： import java.text.SimpleDateFormat.
SimpleDateFormat多线程不安全
09-14
为了在多线程环境中安全地使用SimpleDateFormat类，有几种常见的解决方案： 1. 使用ThreadLocal：可以为每个线程创建一个SimpleDateFormat实例，并将其保存在ThreadLocal变量中。这样每个线程都有自己的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值