JMM与JUC

最新推荐文章于 2024-05-18 16:42:38 发布
最新推荐文章于 2024-05-18 16:42:38 发布
阅读量1.7k 收藏
点赞数 2
分类专栏： JUC 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53374893/article/details/133231934
版权

1.JMM

问题1：请你谈谈你对Volatile的理解

Volatile 是java虚拟机提供轻量级的同步机制

1. 保证可见性

2. 不保证原子性

3. 禁止指令重排

1.1、什么是JMM

JMM Java内存模型  不存在的东西，概念！约定 ！

1.2、关于JMM的一些同步的约定：

1、线程解锁前，必须把共享变量立刻刷回主存，

2、线程枷锁前，必须读取主存中的最新值到工作内存中

3、加锁和解锁的是同一把锁

线程工作内存，主内存。store和write换一个位置

2.Volatile

2.1.保证可见性

package com.kuang.tvolatile;

import java.util.concurrent.TimeUnit;

public class Demo01 {
    //不加volatile ，程序就会陷入死循环，加了保证主内存的可见性
    public volatile static int num=0;

    public static void main(String[] args) {
        new Thread(()->{//线程对主内存的num值的变化是不知道的
            while (num==0){

            }
            System.out.println(num);
        }).start();


        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);

    }
}

2.2不保证原子性

package com.kuang.tvolatile;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//不保证原子性
public class Demo02 {
  //volatile不保证原子性
    private volatile static int num=0;

//改变就会重新加载主存的值，不改变就存一次到工作内存，工作内存相当于线程私有的栈帧，先这么理解
    public  static void  add(){
            num++;
    }
//    public   void  add1(){
//        lock.lock();
//        try {
//            num++;
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            lock.unlock();
//        }
//    }

    public static void main(String[] args) {
        //理论上num结果应该为两万
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
//        Demo02 demo02 = new Demo02();
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                for (int j = 0; j < 1000; j++) {
//                  demo02.add1();
//                }
//            }).start();
//        }

        while (Thread.activeCount()>2){//main gc
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+"   "+num);

    }



}

如果不加lock和synchronized，怎么样保证原子性?

使用原子类，解决原子性问题

package com.kuang.tvolatile;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//不保证原子性
public class Demo02 {
  //volatile不保证原子性
//    private volatile static int num=0;
  public volatile static AtomicInteger num=new AtomicInteger();
//改变就会重新加载主存的值，不改变就存一次到工作内存，工作内存相当于线程私有的栈帧，先这么理解
    public  static void  add(){
            num.getAndIncrement();//AtomicInterger+1方法,CAS
    }
//    public   void  add1(){
//        lock.lock();
//        try {
//            num++;
//        } catch (Exception e) {
//            e.printStackTrace();
//        } finally {
//            lock.unlock();
//        }
//    }

    public static void main(String[] args) {
        //理论上num结果应该为两万
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
//        Demo02 demo02 = new Demo02();
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                for (int j = 0; j < 1000; j++) {
//                  demo02.add1();
//                }
//            }).start();
//        }

        while (Thread.activeCount()>2){//main gc
            Thread.yield();//Thread.yield() 方法是Java中的一个静态方法，用于提示调度程序当前线程愿意放弃其当前时间片。
            // 换句话说，它建议线程愿意暂停执行并为同一优先级的其他线程提供机会。
        }

        System.out.println(Thread.currentThread().getName()+"   "+num);

    }



}

这些类的底层都直接和操作系统直接挂钩 ！在内存中修改值！！！Unsafe类是一个很特殊的存在！

2.3 、指令重排

什么是  指令重排: 你写的程序，计算机并不是按照你写的那样去执行的。

源代码->编译器优化的重排-->指令并行也可能会重排-->内存系统也会重排-->执行

volatile 是可以保持可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！

问：volatile在哪里避免指令重排的现象用的最多，在单例模式！！！

3.彻底玩转单例模式

饿汉式，DCL懒汉式

饿汉式

package com.kuang.single;

//饿汉式
public class Hungry {

    private byte[] bytes1=new byte[1024*1024];
    private byte[] bytes2=new byte[1024*1024];
    private byte[] bytes3=new byte[1024*1024];
    private byte[] bytes4=new byte[1024*1024];


    private Hungry(){

    }

    private final static Hungry HUNGRY= new Hungry();


    public static  Hungry getHungry(){
        return HUNGRY;
    }

}

DCL懒汉式 DCL：双重检测模式

原子性
package com.kuang.single;
//懒汉式
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    //双重检测锁，volatile内存屏障，防止指令重排，
    private volatile static LazyMan lazyMan;

    //双重检测该模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan=new LazyMan();//不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 2和3的顺序，在指令重排的时候
                     */
                }
                //外面那一层判断空 是因为可以减少同步的时间，不会全部同步在锁当中，而一部分代码会因为不为空而直接获取对象。


            }
        }
        return lazyMan;
    }

    //多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();
        }
    }




}

静态内部类

package com.kuang.single;
//静态内部类
public class Holder {
    private Holder(){
        
    }

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
            private static final Holder HOLDER=new Holder();
    }




}

进阶

package com.kuang.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

//懒汉式
//道高一尺魔高一丈
public class LazyMan {

    private static boolean qingjiang=false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if (qingjiang==false){
                qingjiang=true;
            }else {
                throw  new RuntimeException("不要尝试反射破坏单例模式");
            }


        }

    }

    //双重检测锁，原子性，volatile内存屏障，防止指令重排，
    private volatile static LazyMan lazyMan;

    //双重检测该模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan=new LazyMan();//不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 2和3的顺序，在指令重排的时候
                     */
                }
                //外面那一层判断空 是因为可以减少同步的时间，不会全部同步在锁当中，而一部分代码会因为不为空而直接获取对象。


            }
        }
        return lazyMan;
    }

    //多线程并发
//    public static void main(String[] args) {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                LazyMan.getInstance();
//            }).start();
//        }
//    }

    public static void main(String[] args) throws Exception {
//        LazyMan instance = LazyMan.getInstance();

        Field qingjiang = LazyMan.class.getDeclaredField("qingjiang");
        qingjiang.setAccessible(true);

        Constructor<? extends LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan instance2 = constructor.newInstance();
       qingjiang.set(constructor,false);
        LazyMan instance = constructor.newInstance();
        System.out.println(instance);
        System.out.println(instance2);


    }


}

 

 

 

 反射无法破坏枚举

枚举在运行时没有无参构造，但是有一个有参构造，反射拿无参，会抛没有更多的方法

反射拿有参构造，则会抛出，

throw new IllegalArgumentException("Cannot reflectively create enum objects");

 

4.深入理解CAS

Unsafe类

 

5.原子引用

ABA问题

package com.kuang.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {


    //CAS   atomicInteger.compareAndSet()  CAS就是compareAndSet的缩写:比较并交换！
    public static void main(String[] args){
        AtomicInteger atomicInteger=new AtomicInteger(2020);

        //对于我们平时写的SQL：乐观锁！

        
        //expect期望 update更新
        //public final boolean compareAndSet(int expect, int update)
        //如果我期望的值达到了，那么就更新，否则，就不更新,CAS 是CPU的并发原语！
        //捣乱的线程
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());

//        atomicInteger.getAndIncrement();

        //期望的线程
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());
    }



}

6.各种锁的理解

 

package com.kuang.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class CASDemo {


    //解决ABA问题，引入原子引用
    //CAS   atomicInteger.compareAndSet()  CAS就是compareAndSet的缩写:比较并交换！
    public static void main(String[] args){
//        AtomicInteger atomicInteger=new AtomicInteger(2020);
        AtomicStampedReference<Integer> atomic = new AtomicStampedReference<>(1, 1);

        new Thread(()->{
            int stamp = atomic.getStamp();//获取当前版本号
            System.out.println("a1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("a2=>"+atomic.compareAndSet(1, 2, atomic.getStamp(), atomic.getStamp() + 1));
            System.out.println("a3=>"+atomic.compareAndSet(2, 1, atomic.getStamp(), atomic.getStamp() + 1));


            System.out.println("a4=>"+atomic.getStamp());
        },"a").start();


        //乐观锁原理是一样的

        new Thread(()->{
            int stamp = atomic.getStamp();//获取当前版本号
            System.out.println("b1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("b1=>"+(atomic.compareAndSet(1, 6, stamp, stamp + 1)));


            System.out.println("b2=>"+atomic.getStamp());

        },"b").start();







        //
//        //对于我们平时写的SQL：乐观锁！
//
//
//        //expect期望 update更新
//        //public final boolean compareAndSet(int expect, int update)
//        //如果我期望的值达到了，那么就更新，否则，就不更新,CAS 是CPU的并发原语！
//        //捣乱的线程
//        System.out.println(atomicInteger.compareAndSet(2020, 2021));
//        System.out.println(atomicInteger.get());
//
//        System.out.println(atomicInteger.compareAndSet(2021, 2020));
//        System.out.println(atomicInteger.get());
//
        atomicInteger.getAndIncrement();
//
//        //期望的线程
//        System.out.println(atomicInteger.compareAndSet(2020, 6666));
//        System.out.println(atomicInteger.get());
    }



}

对应的思想就是:乐观锁

6.1、公平锁与非公平锁

6.2、可重入锁

package com.kuang.reelock;

//Synchronized
public class Demo01 {
    public static void main(String[] args) {

        Phone phone = new Phone();

        new Thread(()->{
            phone.sms();
        },"A").start();
        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone{

    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName()+"sms");
        call();//这里也有锁

    }

    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"call");

    }


}

 

package com.kuang.reelock.reelock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//Synchronized
public class Demo02{
    public static void main(String[] args) {

        Phone1 phone = new Phone1();

        new Thread(()->{
            phone.sms();
        },"A").start();
        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone1{

    Lock lock =new ReentrantLock();
    public  void sms(){

        lock.lock();
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName()+"sms");
            call();//这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }

    }

    public  void call(){
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName()+"call");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();

        }
    }


}

 

6.3、自旋锁

自定义锁

package com.kuang.spinlock;

import java.util.concurrent.atomic.AtomicReference;

//自旋锁
public class SpinLockDemo {


    /**
     * int 0
     * Thread null
     */
     AtomicReference<Thread> atomicReference=new AtomicReference<>();

    //加锁
    public void lock(){
        Thread thread = Thread.currentThread();

        System.out.println("加锁的是"+thread.getName());

        //第一次进来 为null 成功改变，while条件不成立，不自旋，但是条件没有释放，第二次进来，他不是null了。返回false但是取反为true
        //自旋等待解锁
        while (!atomicReference.compareAndSet(null,thread)){

        }

    }



    //解锁
    public void unlock(){

        Thread thread = Thread.currentThread();
        System.out.println("解锁的是"+thread.getName());
        atomicReference.compareAndSet(thread,null);
    }


    //


}

自定义锁测试

package com.kuang.spinlock;

import java.util.concurrent.TimeUnit;

public class TestDemo {
    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(()->{

            spinLockDemo.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"执行");
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLockDemo.unlock();
            }


        },"A").start();

        new Thread(()->{

            spinLockDemo.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"执行");
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLockDemo.unlock();
            }


        },"B").start();
    }
}

 

6.4、死锁

死锁是多线程或多进程并发执行时可能遇到的一种问题，它具有以下四个必要条件，也被称为死锁的四个特性：

1. 互斥条件（Mutual Exclusion）：至少有一个资源被多个线程或进程竞争使用，且一次只能被一个线程或进程占用。当一个线程或进程占用了资源，其他线程或进程必须等待该资源释放。

2. 请求与保持条件（Hold and Wait）：线程或进程在持有至少一个资源的同时，又请求其他线程或进程持有的资源。即线程或进程在等待其他资源时，仍然保持已经占有的资源。

3. 不可剥夺条件（No Preemption）：已经被一个线程或进程占用的资源不能被其他线程或进程强制性地抢占，只能由占有者主动释放。

4. 循环等待条件（Circular Wait）：存在一个线程或进程的资源请求序列，使得每个线程或进程都在等待下一个线程或进程所持有的资源。形成一个闭环，导致循环等待。

当以上四个条件同时满足时，就可能发生死锁。在死锁发生时，线程或进程无法继续执行，导致系统无法正常运行。因此，死锁的四个特性是死锁问题的根本原因，需要通过合理的资源分配和调度策略来避免死锁的发生。

package com.kuang.sisuo;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String A="A";
        String B="B";

        new Thread(new MyThread(A,B)).start();
        new Thread(new MyThread(B,A)).start();



    }

}


class MyThread implements Runnable {

    private String A;
    private String B;

    public MyThread(String a, String b) {
        A = a;
        B = b;
    }

    @Override
    public void run() {
        synchronized (A){
            System.out.println(A+"获取"+B);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (B){
                System.out.println(B+"获取"+A);

            }

        }




    }
}

如何解决问题 

栈：jstack

堆:  jprofile

调优 

荭色海湾
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
14、深入理解并发可见性、有序性、原子性与JMM内存模型
03-07
深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型
JAVA知识图谱：JVM、JMM、JUC、NIO、Netty、IOC、AOP、Jav-JavaKnowledge.zip
01-29
JAVA知识图谱：JVM、JMM、JUC、NIO、Netty、IOC、AOP、Jav-JavaKnowledge
JUC-JMM三大特性
江黎
09-29 303
JMM(java内存模型，Java Memory model，简称JMM)本身是一种抽象的概念，并不真实存在，它仅仅描述的是一种约定或规范，通过这种规范定义了程序中(尤其是多线程)各个变量的读写访问方式，并决定一个线程对共享变量的写入以及如何变成另一个线程可见，关键技术点都是围绕多线程的原子性、可见性和有序性展开的。 原则：JMM的关键技术点都是围绕多线程的原子性，可见性和有序性展开的。 能干嘛？ 1、通过JMM来实现线程和主内存之间的抽象关系。 2、屏蔽各个硬件平台和操作系统的内存访问差异，以实.
Java多线程并发
hohpower_wangJun的博客
10-25 533
多线程并发 什么是并发编程 并发历史: 早期计算机–从头到尾执行一个程序，资源浪费 操作系统出现–计算机能运行多个程序，不同的程序在不同的单独的进程中运行 一个进程，有多个线程 提高资源的利用率，公平 串行与并行的区别 串行：洗茶具、打水、烧水、等水开、冲茶 并行：打水、烧水同时洗茶具、水开、冲茶 好处：可以缩短整个流程的时间 并发编程目的 摩尔定律：当价格不变时，集成电路上可容纳的元器件的数目，约每隔18-24个月便会增加一倍，性能也将提升一倍。这一定律揭示了信息技术进步的速度。 让程序充分利
一篇神文就把java多线程，锁，JMM，JUC和高并发设计模式讲明白了
m0_63437643的博客
03-17 89
今天给大家分享一篇一线开发大牛整理的java高并发核心编程神仙文档，里面主要包含的知识点有：多线程、线程池、内置锁、JMM、CAS、JUC、高并发设计模式、Java异步回调、CompletableFuture类等。CompletableFuture异步回调；其次咱们来看每个小节都有哪些内容。高并发核心模式之异步回调模式；AQS抽象同步器的核心原理；Java内置锁的核心原理；CAS原理与JUC原子类；JUC显式锁的原理与实战；可见性与有序性的原理；微信公众号获取联系方式。
这就是标题—— JUC.pdf
05-19
JUC是什么 线程 进程 / 线程 线程状态 wait / sleep 并发 / 并行 Lock 使用Lock锁 可重入锁 公平锁 / 非公平锁 Synchronized / Lock 线程通讯 wait()、notify()和notifyAll() ...JUC常用辅助类 ...JMM
JMM
03-17
JMM 具有样条基础的纵向和生存数据的联合模型从github安装： library(devtools)install_github("shanpengli/JMM", build_vignettes = FALSE, ref = "main")
tuling-juc-final.zip
05-23
并发编程代码demo
JUC 学习 - JMM
TyuIn的博客
11-24 167
一、JMM 概述 什么是 JMM？ 内存模型可以理解为在特定的操作协议下，对特定的内存或者高速缓存进行读写访问的过程抽象描述，不同架构下的物理机拥有不一样的内存模型，Java虚拟机是一个实现了跨平台的虚拟系统，因此它也有自己的内存模型，即Java内存模型（Java Memory Model, JMM）。 因此它不是对物理内存的规范，而是在虚拟机基础上进行的规范从而实现平台一致性，以达到Java程序能够“一次编写，到处运行”。 那么究竟什么是内存模型？ 内存模型描述了程序中各个变量（实例域、静态
jar包增量更新分析
junlaiyan的专栏
05-16 261
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 677
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 621
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 905
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 913
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 247
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
C++ 11
qq_65112813的博客
05-17 652
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1024
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 253
java导出excel动态加载多sheet多复杂表头
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器
shijialeya
05-18 382
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器进行数据格式化。
jmm与volatile
07-21
JMM（Java Memory Model）是Java虚拟机规范中定义的一种内存模型，它规定了多线程访问共享内存时的行为。JMM确保了Java程序在不同的平台上都能达到一致的内存访问效果，避免出现歧义和不确定性。 而volatile是Java...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值