线程安全问题

已于 2023-12-02 22:44:18 修改
阅读量28 收藏
点赞数
文章标签： 安全 java jvm
于 2023-11-25 21:02:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luo_tian_yi10086/article/details/134386973
版权

文章目录

线程安全问题

1. 观察线程不安全情况

class Counter {
    int count = 0;
   public void add(){
       count++;
    }
}
public class ThreadDemo13 {

    public static void main(String[] args) {
         Counter counter = new Counter();
         Thread t1 = new Thread(()->{
             for (int i = 0; i < 50000; i++) {
                 counter.add();
             }
         });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                counter.add();
            }
        });
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
        System.out.println(counter.count);
    }
}

在这里插入图片描述

上述代码中两线程分别对count进行50000次自增操作，但是结果并不是100000，结果也并不是固定为63079而是每次运行结果都不一样，没有达到预想的结果，这就是线程不安全。

2.线程安全的概念

通俗的说，代码能达到预期结果线程就是安全的，没到预期结果就不安全。

3.线程为什么不安全？

上面的线程不安全的代码中, 涉及到多个线程针对 counter.count 变量进行修改.
此时这个 counter.count 是一个多个线程都能访问到的 “共享数据”。

线程对count的操作流程如下图：
在这里插入图片描述
上图可看出线程对count自增操作有三个步骤：

1 load操作，将内存中count的值写入进程。
2 add操作，将写入的值进行自增操作。
3 save操作，将自增后count的值重新写入内存

每个进程都有着三个操作，因为线程是抢占式执行的，所以着三个操作也在抢占式执行，三个操作都不固定，就有可能发生以下的情况：
在这里插入图片描述
由上图可以看出进程t1和t2分别对count进行了一次自增操作但是内存中的count只从1变为了2，这就是因为共享内存使进程t1和t2写入了同一个count值导致最终只改变了一次最终值。

以上只是线程不安全的其中一个情况还有很多种情况使count不能以预想的结果输出，但是所有情况都是因为共享内存引起的。

3.1线程不安全的原因

  1. 抢占式执行（线程不安全的源头）。
  2. 多个线程修改一个变量。
  3. 修改啊操作不是原子的。
  4. 内存可见性，引起线程不安全。
  5. 指令重排序，引起线程不安全

其中四，五条原因和以上对count的自增例子无关，由其他场景引起。

4线程的原子性

4.1什么是原子性

原子性是指一个操作或一组操作要么全部执行成功，要么全部不执行，不会出现部分执行的情况。

例如：一个公共厕所，当厕所里面有人时，门是上锁的外面的人进不去，只有当里面的人出来后，外面的人才可以进入，不会出现里面的人还在上厕所，外面又进去一个人也同时上厕所的情况，这就是原子性。

4.2不保证原子性会给多线程带来什么问题

如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的。

这个和线程的抢占式执行密切相关，如果线程不是抢占式执行的就算不保证原子性也没有问题。

5.synchronized 关键字

5.1synchronized的特性

互斥

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待.。

  • 进入 synchronized 修饰的代码块, 相当于 加锁
  • 退出 synchronized 修饰的代码块, 相当于 解锁
    在这里插入图片描述

当一个线程先上了锁之后，其他线程就只能等待这个线程释放。

针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒一个新的线程, 再来获取到这个锁。

可重入

一个线程针对同一个对象连续加锁两次, 如果没问题, 就是可重入的, 如果有问题, 就是不可重入的。

死锁情况：

首次加锁，成功
lock()
第二次加锁，锁已经被占用，阻塞等待
lock()
只有等第一次的锁被释放，第二次才能加锁成功，但是第一个锁也是由同一个线程完成的，此时就会出现死锁的情况。

然而synchronized是可重入的锁，就没有上面的死锁情况

5.2Java 标准库中的线程安全类

Java 标准库中很多线程都是线程不安全的, 这些类会涉及到多线程修改共享数据, 但是又没有加锁的措施。

  • ArrayList
  • LinkedList
  • HashMap
  • TheeMap
  • HashSet
  • TreeSet
  • StringBuilder

有些类是线程安全的, 强行加锁了

  • Vector(不推荐用)
  • HashTable(不推荐用)
  • ConcurrentHashMap
  • StringBuffer

还有一种虽然没有加锁, 但是不涉及修改的类, 也是线程安全的

  • String

上述描述可以看出常用的集合都没有加锁，线程并不安全，而强行加锁的都不推荐使用或者不常用，之所以这样是因为，内置synchronized 相对来说更安全一点, 但是安全带来的另一种影响是性能上的损耗, 要在适当的场景中合理的使用。

6死锁

6.1死锁的概念

死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

6.2 死锁的情况

  1. 一个线程一把锁，将同一把锁第二次加在线程身上时，如果锁是可重入锁就没事，是不可重入锁就会出现死锁的情况。
  2. 两个线程两把锁，即便是可重入锁也会锁死。
public class ThreadDemo14 {
    public static void main(String[] args){
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker2){
                    System.out.println("t1获取了两把锁");
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker2){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker1){
                    System.out.println("t2获取了两把锁");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

在这里插入图片描述
这里可以看到，以上代码是没有任何输出的，原因就在于，t1线程在获取锁1后尝试获取锁2，而t2线程在获取锁2后尝试获取锁1，两个线程都在等对方释放锁，这样就造成死锁的情况。

  1. 多个线程多把锁
    这里引入一个哲学家就餐问题来进行理解：
    在这里插入图片描述
    如上图：五个哲学家围在一张桌子前，桌子中间放着鸡腿，以及编号为1-5的五根筷子，只有哲学家同时拿起两根筷子才可以吃到鸡腿。

这时每个哲学家都是一个线程，他们都有两中状态：

  1. 拿不起两根筷子（筷子被其他人占用），什么都不做。（线程阻塞等待）
  2. 拿起了两根筷子，吃鸡腿。（线程获取锁并执行）

这时就会有一种极端的情况发生：
在这里插入图片描述
如上图所示，五位哲学家同时拿起了左手边的筷子，这时候没有一位哲学家同时拥有两根筷子，所有哲学家都在等待右手边的人吃完释放筷子，这时候就进入了循环等待的情况，导致进程直接僵住了，造成死锁。

6.3如何避免死锁

产生死锁的四个必要条件：

  1. 互斥使用：当一个锁被占用时，其他线程不能再获取这把锁，即当线程想要获取已经被占用的锁时就会进入阻塞等待状态，等待锁的释放。
  2. 不可抢占：当一个锁被占用时，其他想要获取这把锁的线程不能强制获取，只有等待锁被释放才可以获取到。
  3. 请求和保持：当一个线程已经获取了一把锁，同时尝试去获取另一把锁的时候，第一把锁不会因为第二把锁的请求而被释放。
  4. 循环等待：三个线程A,B,C ，分别获取到锁A,B,C ，这时线程A要获取锁B，线程B要获取锁C，线程C要获取锁A，这样就形成了一个等待环路，所有线程都在等待对方释放锁。

6.4 打破死锁

java中以上四个死锁必要条件中前三条是synchronized的基本特性不可改变，所以打破死锁就只能从第四题循环等待入手。

继续引用上面的哲学家就餐问题：

我们给哲学家们制定一个规则，每人只能先拿起左右手边编号较小的筷子，再拿起编号较大的筷子，这样就会变成以下这样：

在这里插入图片描述
这样一来，有两个哲学家都要拿一号筷子，这样就会有一个哲学家拿不到，这时根据规则只能拿小编号筷子，这个没拿到筷子的哲学家就要等待一号筷子被释放，这时5号筷子会剩余，再根据规则，从5号筷子开始拿4,5号筷子的哲学家吃完放下筷子，这样拿3号筷子的哲学家就能拿起4号筷子…一直循环到拿一号筷子的哲学家放下筷子，这样最初没拿到1号筷子的哲学家就可以拿起1,5号筷子最后就餐。

这样修改以上死锁的代码：

public class ThreadDemo14 {
    public static void main(String[] args){
        Object locker1 = new Object();
        Object locker2 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker2){
                    System.out.println("t1获取了两把锁");
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (locker1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (locker2){
                    System.out.println("t2获取了两把锁");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

在这里插入图片描述
让两个线程都先获取锁1，再获取锁2，这样就会打破死锁。

7. volatile 关键字

被volatile关键字修饰的变量，能够保证其内存的可见性。加上volatile后，强制读写内存，速度会变慢，但是数据会更准确。
当一个变量被volatile修饰的时候：

  • 修改被修饰变量时：
  1. 改变线程工作内存中变量的值。
  2. 将改变后变量的值从工作内存中刷新到主内存。
  • 读取volatile修饰的变量的时候：
  1. 从主内存中读取volatile修饰的变量的最新值到线程的工作内存中。
  2. 从工作内存中读取到volatile变量的值。

如下代码对比：
不加volatile的情况：

class MyCounter{
     public int flag = 0;

}
public class ThreadDemo15 {
    public static void main(String[] args) {
        MyCounter myCounter = new MyCounter();
        Thread t1 = new Thread(()->{
            while (myCounter.flag == 0){
               
            }
            System.out.println("t1循环");
        });
        Thread t2 = new Thread(()->{
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个整数：");
            myCounter.flag = scanner.nextInt();
        });
        t1.start();
        t2.start();
    }
}

在这里插入图片描述
加上volatile的情况：

class MyCounter{
    volatile public int flag = 0;

}
public class ThreadDemo15 {
    public static void main(String[] args) {
        MyCounter myCounter = new MyCounter();
        Thread t1 = new Thread(()->{
            while (myCounter.flag == 0){
                
            }
            System.out.println("t1循环");
        });
        Thread t2 = new Thread(()->{
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个整数：");
            myCounter.flag = scanner.nextInt();
        });
        t1.start();
        t2.start();
    }
}

在这里插入图片描述
从上面两个代码实例的运行结果可以看出，在没有volatile的时候，线程2里面修改了flag的值后并没有使线程1的循环终结，代码一直在循环，在加上volatile关键字后线程1的循环可以正常终止。

8. wait 和 notify

在实际代码运行中，线程之间时抢占式执行的，但是有时候我们的代码需要控制某些线程的先后顺序，这时候可以用wait 和 notify.

wait：让线程进入到等待状态。
notify：唤醒当前对象上等待的线程。

8.1 wait()方法

wait 对代码起到的影响：

  1. 使执行到wait()的线程进入等待状态。
  2. 释放当前线程的锁。
  3. 如果在等待中的线程被notify唤醒，线程会重新获取这把锁。

wait要搭配synchronized使用，否则的话wait会直接抛出异常

wait结束等待的条件：

  1. 其他现场调用了被wait对象的notify方法。
  2. wait等待时间超时（wait有timeout参数版本，可以指定等待时间）
  3. 其他线程调用该等待线程的 interrupted 方法, 导致 wait 抛出异常。

8.2 notify()方法

与wait对应nofity是唤醒等待中的线程，但是使用nofity时要注意：

  1. nofity要在wait同一个代码块中使用，使等待中的线程被唤醒，重新获取该对象的锁。
  2. 如果有多个线程处于等待状态，nofity会随机唤醒一个，不能指定唤醒。

8.3 wait和notify的代码实例

wait()的使用：

public class ThreadDemo16 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        synchronized (object) {
            System.out.println("wait 之前");
            object.wait();
            System.out.println("wait 之后");
        }
    }
}

在这里插入图片描述
以上代码与运行 结果可看出，当线程调用wait()方法后便没有了动静，只打印出了“wait之前”的日志，“wait之后”的日志并没有打印出来。
notify()方法的使用：

public class ThreadDemo17 {
    public static void main(String[] args) {
        Object object = new Object();
        Thread t1 = new Thread(() -> {
            System.out.println("t1wait:之前");
            try {
                synchronized (object) {
                    object.wait();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("t1wait:之后");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("t2notify:之前");

            synchronized (object) {
                object.notify();
            }

            System.out.println("t2notify:之后");
        });
        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        t2.start();
    }
}

在这里插入图片描述
上述代码中线程t1调用wait()方法打印wait的日志，线程t2调用notify()方法打印notify日志，可以从打印结果看出，t1线程wait之后便没有了动静，开始执行t2线程，当notify()方法被t2调用后，t1线程的wait状态被打破。

8.4 notifyAll()方法

与notify()方法类似不同的是notify()方法在有多个线程同时等待时会随机唤醒一个，而notifyAll()方法在多个线程同时等待时会将等待的线程同时全部唤醒。

public class ThreadDemo17 {
    public static void main(String[] args) {
        Object object = new Object();
        Thread t1 = new Thread(() -> {
            System.out.println("t1wait:之前");
            try {
                synchronized (object) {
                    object.wait();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("t1wait:之后");
        });
        Thread t3 = new Thread(() -> {
            System.out.println("t3wait:之前");
            try {
                synchronized (object) {
                    object.wait();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("t3wait:之后");
        });
        Thread t4 = new Thread(() -> {
            System.out.println("t4wait:之前");
            try {
                synchronized (object) {
                    object.wait();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("t4wait:之后");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("t2notifyAll:之前");

            synchronized (object) {
                object.notifyAll();
            }

            System.out.println("t2notifyAll:之后");
        });
        t1.start();
        t3.start();
        t4.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        t2.start();
    }

在这里插入图片描述
代码大致和notigy中一致，只是多加了两个和t1一模一样的线程t3和t4同时将t2线程的notify改为notifyAll这是就出现了以上的运行结果，线程t1,t3,t4走到wait时全部进入等待状态，在t2调用notifyAll后，三个线程全部被唤醒，开始抢占式执行。

luo_tian_yi10086
关注
【多线程】线程安全问题
程序猿教你打篮球的博客
04-25 7401
本期主要讲解： 1.—段线程不安全的代码 2.线程不安全的原因 2.1随机调度 2.2修改共享数据 2.3原子性 2.4内存可见性 2.5指令重排序 3.synchronized加锁操作 3.1针对指定对象加锁 3.2针对this加锁 3.3针对类对象加锁 3.4 synchronized疑难解答 3.5 synchronized是可重入锁
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 6307
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
servlet线程安全问题
PDyee的博客
02-09 2611
Servlet线程安全问题 线程安全问题 当我们访问servlet的时候，我们需要执行实例化操作,创建一个servlet对象。而我们tomcat容器可以让多个线程并发访问Servlet，如果在方法当中对成员变量做修改，就会出现线程安全问题。 如何保证线程安全 1、synchronized :这种方式会大量的造成线程堵塞 public class MyServlet extends GenericServlet{ @Override public synchronized void service(S
Servlet的线程安全问题
Y4tacker的博客
02-04 4158
文章目录Servlet的线程安全问题引入Servlet的多线程机制如何修复1.实现 SingleThreadModel 接口2.避免使用成员变量3.同步对共享数据的操作思考与小结参考文章 Servlet的线程安全问题 引入 首先看看这样的代码，有什么问题 这里既要求cmd不能包含Calculator又必须要包含Calculator，能做到吗，当然是可以的 Servlet的多线程机制 Servlet实际上是一个单件，当我们第一次请求某个Servlet时，Servlet容器将会根据web.xml配置文件或者是
单例模式中的线程安全问题
X_H学Java的博客
04-04 1万+
单例模式是面试中设计模式里考的最多的一个，本文就单例模式中的饿汉模式和懒汉模式中的线程安全进行说明，以及分别使用synchronized和双重校验锁使懒汉模式在多线程环境下为线程安全的
JAVA线程安全问题
qq_42682991的博客
11-28 3993
卖票的过程中出现了线程安全问题，有重票和错票的问题。 为什么会出现这个问题？ 当某个线程在操作卖票的过程中尚未完成卖票操作，其他线程也参与进来操作卖票，就会出现线程安全问题，（主要是共享数据（nums）的问题） 怎么去解决这个问题？ 当某个线程在操作卖票的时候，其他线程不能参与进来，直到这个线程操作完成（即使这个线程阻塞了也得等这个线程执行完成），其他线程才能进来。 java里面我们通过同步机制来解决线程安全问题 方式一：同步代码块 synchronized(同步监视器){ } ..
Servlet 的线程安全问题
weixin_42578100的博客
11-14 3135
Servlet 的线程安全问题 在 Servlet 中使用的是多线程方式来执行 service()方法处理请求，所以我们在使用 Servlet 时需要考虑到线程安全问题，在多线程中对于对象中的成员变量是最不安全的，所以不要在 Servlet 中通过成员变量的方式来存放数据，如果一定要使用成员变量存储数据，在对数据 进行操作时需要使用线程同步的方式来解决线程安全问题，避免出现数据张冠李戴现象。 ...
Java多线程基础-8：单例模式及其线程安全问题
wyd_333的博客
05-06 2740
单例指的就是单个实例（instance），也就是单个对象（对象就是类的实例）。单例模式指的是某个类在进程中只有唯一一个实例（在一个程序中，只能创建一个实例（一个对象），不能创建多个对象）。按理来说，在写代码的时候多 new 几次，就能创建多个对象了。但在语法上，是有办法禁止这样多 new 几次的操作的。也就是说，Java中的单例模式，实际上是借助 Java 语法，保证某个类只能够创建出一个实例，而不能被new多次。为什么会有这样的用途？其实原因是很简单的：在有些场景下，本身它就要求某个概念是单例的。
高并发之——SimpleDateFormat类的线程安全问题和解决方案
热门推荐
冰河的专栏
02-19 1万+
首先问下大家：你使用的SimpleDateFormat类还安全吗？带着这个问题再来看本文。 提起SimpleDateFormat类，想必做过Java开发的童鞋都不会感到陌生。没错，它就是Java中提供的日期时间的转化类。这里，为什么说SimpleDateFormat类有线程安全问题呢？有些小伙伴可能会提出疑问：我们生产环境上一直在使用SimpleDateFormat类来解析和格式化日期和时间类型...
Java 单例模式线程安全问题
08-29
Java 单例模式线程安全问题详解 Java 单例模式线程安全问题是指在 Java 中实现单例模式时，如何确保线程安全的问题。单例模式是指在整个应用程序生命周期中，只有一个实例存在的设计模式。这种模式可以提高性能，...
关于如何解决HashMap线程安全问题的介绍
08-22
4. 避免在多线程环境中直接使用HashMap：如果你确定不需要在多线程环境下共享HashMap，那么可以考虑局部变量的方式，只在单个线程中使用HashMap，这样就无需担心线程安全问题。 总结起来，理解HashMap的线程不安全...
Java线程安全问题小结_动力节点Java学院整理
08-30
Java线程安全问题主要涉及到并发环境下多个线程对共享资源的访问和修改，这可能导致数据不一致、死锁等问题。Java内存模型（JMM）是Java语言为了保证跨平台的并发正确性而设定的一套规范，它规定了线程如何访问和...
高级程序员必会的HashMap的线程安全问题，适用于0~2年的.7z
08-03
本篇将深入探讨HashMap的线程安全问题，并提供相关的解决方案。 首先，我们需要了解HashMap在多线程环境下可能出现的问题： 1. **并发修改异常（ConcurrentModificationException）**：当多个线程同时修改HashMap...
基于java线程安全问题及原理性分析
08-29
"基于java线程安全问题及原理性分析" 基于 Java 线程安全问题是指在多线程环境中，多个线程访问同一个对象时可能发生的安全问题。这种问题产生的根本原因是共享数据存在被并发修改的可能，即一个线程读取时，允许另...
网 络 安 全
最新发布
数字人生
10-06 1596
定义：网络安全是指网络系统的硬件、软件及其系统中的数据受到保护的状态。范畴硬件安全：包括网络设备、服务器、终端等物理设备的安全。软件安全：包括操作系统、应用软件、数据库等的安全。数据安全：包括数据的保密性、完整性、可用性等。
数据库常见的安全特性有哪些
lunan的博客
10-05 700
不同的数据库管理系统（如MySQL、PostgreSQL、Oracle等）在实现这些安全特性时可能会有所差异，但大多数都具备以上关键安全功能。数据库系统会通过身份验证来确定用户的身份，常见的方式有用户名/密码验证、基于证书的验证、多因素验证（MFA）等。数据库通过约束（如外键约束、唯一性约束、非空约束等）确保数据的一致性和完整性，防止未经授权的修改。数据库会对用户的权限进行管理，确保只有被授权的用户可以执行特定的操作。数据库管理员应确保每个用户只拥有执行其工作所需的最少权限，以减少潜在的风险。
如何提升企业安全生产标准化？蓝燕云安全生产标准化管理平台介绍
2409_87787504的博客
10-06 559
我国安全生产标准化体系由国家一系列详尽而全面的规定构成，旨在全方位提升企业的安全生产管理水平，确保生产活动在安全的环境下进行。核心在于《企业安全生产标准化基本规范》(GB/T 33000-2016)，该规范明确了企业建立、保持与评定安全生产标准化管理体系的原则、一般要求以及八个核心技术要求体系，包括目标职责、制度化管理、教育培训、现场管理、安全风险管控及隐患排查治理、应急管理、事故管理和持续改进。这一标准广泛适用于工矿商贸企业，并鼓励其他行业参照执行。
余承东直播论道智能驾驶：激光雷达不可或缺，华为ADS 3.0引领安全创新
linjingtu的博客
10-05 448
余承东与马东的这场直播交流，不仅为公众提供了深入了解智能驾驶技术的机会，也展现了华为在智能驾驶领域的坚定信心和前瞻布局。激光雷达的广泛应用、多传感器融合的技术路线、以及鸿蒙智行ADS 3.0的创新特性，共同构成了华为智能驾驶技术的核心竞争力。随着技术的不断进步和市场环境的不断变化，华为有望在智能驾驶领域取得更加显著的成果，为用户带来更加安全、便捷、智能的出行体验。
解读SimpleDateFormat的线程安全问题及解决策略
本文详细探讨了SimpleDateFormat在多线程环境中的线程安全问题以及相应的解决方案。SimpleDateFormat类在处理日期格式化和解析时，内部依赖一个Calendar对象来存储和管理日期信息。由于其静态特性，当多个线程共享一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值