Java 从多线程到并发编程（六）—— 并发 同步 锁 阻塞 synchronized四种应用形式

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量2.5k 收藏 2
点赞数 2
分类专栏： Java 从多线程到并发编程 文章标签： 多线程 java synchronized 阻塞 类锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43178828/article/details/113853983
版权

文章目录

前言 ´･ᴗ･`

  • 继上一次我们主要学习了线程礼让yield 线程强制执行join 线程自我阻塞sleep等相关的知识

  • 本节将会帮助你了解…

    • 并发 同步 锁 阻塞 互斥 临界资源 synchronized概念浅析
    • synchronized 四种 实现形式的理解以及demo

毕竟线程不讲 同步与线程安全 等于没怎么讲2333

这一节可以说是解决生产者消费者问题的基础之一，好好学：）

并发 不安全案例

在前面我们有个例子 用Runnable 实现 三个robot抢票这个案例 如代码：

package com.base.threadlearning.threadVSrunnable;



public class RunnableTicket implements Runnable{
    private static final int TICKETS=10;
    private int tickets;
    private boolean flag;

    RunnableTicket(){
        tickets=TICKETS;
        flag=true;
    }
    public void setFlag(Boolean flag){
        this.flag = flag;
    }

    @Override
    public void run(){
        while(flag){
            if(tickets<=0) break;

            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" get the "+tickets--+" tickets");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        RunnableTicket ticket_station = new RunnableTicket();
        String[] Robot_array = {"Robot A","Robot B","Robot C"};

        for(String i : Robot_array){
            new Thread(ticket_station,i).start();
        }
        Thread.sleep(4000);
        TicketController ticketController = new TicketController(ticket_station);
        new Thread(ticketController).start();
    }
}

这里多个线程访问同一个对象资源 被称为并发

那么这里我们的逻辑 处理并发 导致最后票竟然会出现-1这种情况，如图：
在这里插入图片描述

但流程控制中我们有
在这里插入图片描述
当小于等于0的时候停止挖票的逻辑 所以这个处理并发的逻辑问题出在哪？
在这里插入图片描述
这里 线程执行相互独立 假设有一个线程A跑到1这个地方 这时tickets 给我们公开的信息是还剩一张 但实际上线程A应该算是拿到票了 只不过等待一下网络请求的200ms

就好像你买东西 都把东西放到收银台了（预定了） 就差付钱了

这时线程B看到 诶 还有1张 我还可以抢 于是他也开抢 他也预定了这张票

这就相当于本来只有一张票 却好像有两张票都能被预定一样

如果还有线程CDEFG 那要多少有多少 —— 只要第一个线程A没有更新tickets值

或许有个思路就是 我预约完立即更新tickets值 但实际上 因为tickets值在服务器 你客户端请求服务器当然需要时间 所以不可能实现

那么就只剩下一个更加直接的方法 上锁 也被称为同步

说白了 好像上厕所 咱们一个一个来 上厕所锁门 后面的人就得等着 不能蜂拥而上 只能串行执行

线程同步 互斥体 阻塞 锁 感性理解

既然如此 我们只能想上厕所一样 排好队 这可以被称为 在对象的等待池中 形成队列

还记得第一篇文章讲进程的时候 我们说单核CPU只能同时为一个进程提供计算服务
而其他进程只能干瞪眼 乖乖排队就绪 直到自己的优先级达到了才行 这里 这个特点上也非常类似

如果你想让一个方法 实现像厕所一样的效果 也就是调用此方法必须同步执行 调用线程只能一个一个操作

其实我们这种同步方式也有个名字 称为互斥体，它实现了“互相排斥”（mutual exclusion）同步的简单形式（所以名为互斥体(mutex)），其定义就是 互斥体禁止多个线程同时进入受保护的代码“临界区”（critical section），线程与线程之间互斥

我们称 占用当前对象的线程 也就是上到厕所的线程 拿到了锁 即你终于可以上厕所的时候 上了一把锁一样
上完厕所后你就释放（release）了锁（解开了锁 否则别人上不了）

另一个角度来说 上不了厕所 在等的那批人 也就是被阻塞了 被门挡住了

这个时候就非常低效 因为等待的人只能无所事事

当然如果他们顺便玩玩手机刷刷抖音 那就说明他们是多线程操作——上厕所的线程阻塞了 不妨碍其他刷抖音的线程跑起来啊

https://www.cnblogs.com/weibanggang/p/9470718.html

Synchronized——同步的简单实现

我们可以使用synchronized 这个关键字 实现互斥 线程同步的效果 这个关键字可以用于方法、代码块、类、静态方法（用大括号括起来即可）

但是无论如何 其修饰的 或者说作用的根本 是对象

比方说 如果两个线程各自作用一个对象 那么你再synchronized这两个对象 这两个线程依然可以交替 “多线程”的“并行”执行

因为每个对象（比如 类似我们之前的案例 两个卖票站）只遇到一个线程在抢票 线程与线程之间并不能形成互斥

但是如果你理解为作用的是那个方法 你会以为同步的是方法那个函数对象 那你就以为这里线程会同步执行

事实上我们确实只需要保证所谓线程是互斥的 访问 临界资源 即一个一个来上厕所 所以锁的是临界资源 锁的是坑位 不是锁方法 或者代码块本身

我们直接上例子你就明白了：
这里 三个挖票机器人vs一个售票处

package com.base.threadlearning.threadState;
// 队列+锁机制 保证线程安全 否则同时操作同一个对象并发就会出问题
// 线程持有锁 会导致其他线程挂起 time wait
// 优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置！

public class ThreadSync {
    public static void main(String[] args) {
        // 同一个ticket station
        ticket station = new ticket();

        new Thread(station,"a ").start();
        new Thread(station,"b ").start();
        new Thread(station,"c ").start();
    }

}


class ticket implements Runnable{
    private int ticket = 10;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    
    private synchronized void buy() throws InterruptedException {
        if(ticket<=0) {
            flag = false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"get "+ticket--);
    }
}

这里执行确实是同步执行的 三个robot互斥 结果如下：

a get 10
c get 9
b get 8
c get 7
a get 6
c get 5
b get 4
c get 3
a get 2
c get 1

Process finished with exit code 0

那三个挖票机器人VS三个售票处 各自在各自的售票处挖 1v1

public class ThreadSync {
    public static void main(String[] args) {
        // 同一个ticket station
//        ticket station = new ticket();

        new Thread(new ticket(),"a ").start();
        new Thread(new ticket(),"b ").start();
        new Thread(new ticket(),"c ").start();
    }
}
// 其他部分代码相同 就不写了

结果：

b get 10
c get 10
a get 10
a get 9
c get 9
b get 9
c get 8
a get 8
b get 8
a get 7
b get 7
c get 7
c get 6
b get 6
a get 6
a get 5
c get 5
b get 5
c get 4
a get 4
b get 4
a get 3
c get 3
b get 3
a get 2
c get 2
b get 2
a get 1
c get 1
b get 1

我们可以看到 三个线程并没有互斥 彼此并不干扰 而且如果你三个三个看 （每个售票处的1号票 2号票······）你可以发现robot顺序不同 bca - > acb -> bac 这也表现了线程并没有同步执行

那么我们这里修饰了buy方法 如果换成run 会怎么样？

synchronized的四种修饰形式解读

这里我给你个表：
作用对象就是那些本应该互斥的线程 线程（挖票机）调用售票处的方法（售票终端）进行挖票 或者说正在等厕所坑位空闲的我。。。

上锁对象就是 所谓临界资源 需要保护的资源 也就是厕所坑位

修饰内容上锁对象作用对象（互斥体）
代码块（同步代码块）代码调用这个代码块的对象
方法（同步方法）方法调用这个方法的对象
静态方法静态方法所属类的所有对象实例（静态方法属于类信息）
类括号范围类的所有对象实例

上面这张表就是四种修饰形式

那你说改成run有区别吗？答案是没有

因为作用（使同步）的对象还是那三个挖票机 而临界资源也没什么本质变化 因为是三个售票处 三个售票处各自tickets-- 以及网络请求300ms延时 所以出来的效果一样的 如下：

a get 10
b get 10
c get 10
b get 9
a get 9
c get 9
a get 8
b get 8
c get 8
c get 7
a get 7
b get 7
b get 6
c get 6
a get 6
b get 5
c get 5
a get 5
c get 4
b get 4
a get 4
a get 3
b get 3
c get 3
b get 2
a get 2
c get 2
c get 1
a get 1
b get 1

还是各自为政 各挖各的售票处

那如果对同一个售票处 我修饰run会怎么样？也即是真正的并发情况下

这时代码如下：

package com.base.threadlearning.threadState;

public class ThreadSync {
    public static void main(String[] args) {
        // 同一个ticket station
        ticket station = new ticket();

        new Thread(station,"a ").start();
        new Thread(station,"b ").start();
        new Thread(station,"c ").start();
    }

}
class ticket implements Runnable{
    private int ticket = 10;
    boolean flag = true;
    @Override
    public synchronized void run() {
        while (flag){
            try {
                buy();
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    private void buy() throws InterruptedException {
        if(ticket<=0) {
            flag = false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"get "+ticket--);
    }
}

这时的结果也是绝了：

a get 10
a get 9
a get 8
a get 7
a get 6
a get 5
a get 4
a get 3
a get 2
a get 1

感觉a承包了这个station售票处。。为什么？

我们这里的临界资源 上锁的东西变为整个售票处 意味着只要a挖票没挖完 永远不释放售票处的锁 那么b c都别想进售票处操作

而前面我们上锁的只是买票的函数接口buy而已 也就是你a买完一张 就把锁释放了
接下来我们a b c都可以买 全看调度器怎么抉择而已

同步代码块的使用

这个和同步方法差不多·一般是做等效 比如 我们利用同步代码块等效一下 同步run方法 就可以这么写：

class ticket implements Runnable{
    private int ticket = 10;
    boolean flag = true;
    @Override
    public synchronized void run() {
        synchronized (this){
            while (flag){
                try {
                    buy();
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }


    }

那么为啥还要用同步代码块呢？我的理解是 很多情况下函数并非最小功能的执行单位 或者说需求同步的最小单位 那么函数粒度不够 就用同步代码块即可

比如 函数可能涉及很多局部变量 但是真正需要同步上锁的只有计算部分 那干脆保护更核心的部分好了：）

同步“静态”对象

所谓静态的对象 就是类和静态的方法

为什么说是静态的 因为类的属性以及其静态方法是写死在class字节码文件里面的 这些配置不变

因此就会有很有意思的情况
比如对于第三种方式 当你synchronized一个静态方法 然后线程使用它的时候 这个静态方法本来作为一个类似工具 用来即时计算的东西 但实际上却进行了同步 里面的数据是被保护的 我们看个例子

package com.base.threadlearning.threadState;

public class ThreadSync {
    public static void main(String[] args) {

        new Thread(new ticket(),"a ").start();
        new Thread(new ticket(),"b ").start();
        new Thread(new ticket(),"c ").start();
    }

}
class MathTool{
    private static int count=30;

    public synchronized static void getNum(String threadName) throws InterruptedException {
        System.out.println(threadName+" getNum "+count--);
    }

}

class ticket implements Runnable{
    private int ticket = 10;
    boolean flag = true;
    @Override
    public synchronized void run() {
        synchronized (this){
            while (flag){
                try {
                    buy();
                    // request time
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void buy() throws InterruptedException {
        if(ticket<=0) {
            flag = false;
            return;
        }
        Thread.sleep(100);
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName+" get "+ticket--);
        MathTool.getNum(threadName);
    }
}

MathTool这个类作为工具类 有静态方法供人调用 结果就可以实现三个售票处总共票被挖取的倒计效果（实时显示三个站还剩多少票）

a  get 10
b  get 10
c  get 10
a  getNum 30
c  getNum 29
b  getNum 28
c  get 9
a  get 9
b  get 9
c  getNum 27
b  getNum 26
a  getNum 25
b  get 8
a  get 8
c  get 8
b  getNum 24
c  getNum 23
a  getNum 22
b  get 7
c  get 7
a  get 7
b  getNum 21
a  getNum 20
c  getNum 19
b  get 6
a  get 6
c  get 6
b  getNum 18
c  getNum 17
a  getNum 16
b  get 5
a  get 5
c  get 5
b  getNum 15
c  getNum 14
a  getNum 13
a  get 4
c  get 4
b  get 4
a  getNum 12
b  getNum 11
c  getNum 10
c  get 3
a  get 3
b  get 3
c  getNum 9
b  getNum 8
a  getNum 7
b  get 2
c  get 2
a  get 2
b  getNum 6
a  getNum 5
c  getNum 4
b  get 1
b  getNum 3
c  get 1
a  get 1
c  getNum 2
a  getNum 1

如果不同步这个静态方法 那么count这个变量便不再受到保护 （count只有一个 因为是静态的）
在这里插入图片描述
同步静态的方法 我们只能保护方法里面的变量 但是如果同步类 那效果是 —— 保护所有类实例 换言之 只要是使用了这个类字节码的类实例 ClassName.class 都用的同一把锁~

类锁

前面三种基本上都是针对一个对象 比如一个方法 一个代码块 又称为对象的内置锁 是单个对象上锁

但是这里是类锁 所有类实例共用一把锁 相当于一群实例共有的锁

这里我出道题： 如何让三个售票处 所有的票 都是一张一张卖的 比如一个售票处10张票 那么就会30张票一张一张出 这不是三个售票处 10张票售卖还能并行三线程

限定条件：

  • 主线程长这样的（就是之前 三个售票处那种demo）
public class ThreadSync {
    public static void main(String[] args) {

        new Thread(new ticket(),"a ").start();
        new Thread(new ticket(),"b ").start();
        new Thread(new ticket(),"c ").start();
    }

}
  • 在之前三个售票处的demo基础上 只更改两行代码

类锁demo答案

我给上代码 你们看看功能实现了没：

package com.base.threadlearning.threadState;

public class ThreadSync {
    public static void main(String[] args) {

        new Thread(new ticket(),"a ").start();
        new Thread(new ticket(),"b ").start();
        new Thread(new ticket(),"c ").start();
    }

}


class ticket implements Runnable{
    private int ticket = 10;
    boolean flag = true;
    @Override
    public void run() {
        synchronized (ticket.class) {
            while (flag) {
                try {
                    buy();
                    // request time
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void buy() throws InterruptedException {

            if (ticket <= 0) {
                flag = false;
                return;
            }
            Thread.sleep(100);
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " get " + ticket--);
        }

}

a  get 10
a  get 9
a  get 8
a  get 7
a  get 6
a  get 5
a  get 4
a  get 3
a  get 2
a  get 1
c  get 10
c  get 9
c  get 8
c  get 7
c  get 6
c  get 5
c  get 4
c  get 3
c  get 2
c  get 1
b  get 10
b  get 9
b  get 8
b  get 7
b  get 6
b  get 5
b  get 4
b  get 3
b  get 2
b  get 1

怎么实现的呢？原因全在这两行：

synchronized (ticket.class) {

}

发现了没有 无论多少售票处 没有意义 因为售票处实例都被同一把锁锁住了
因此 就好像有个农贸市场 售票市场 里面三个售票处 你人只能一次进去一个 当然你选哪家售票处 那随便（这个demo就默认选一家了）

又因为 我们控制的范围是run 所以只有robot a用完了整个售票市场 他挖完自己所有所需的票 b c才能进去

总结 ´◡`

这四种实现形式都有相应的应用 活学活用很难：） 不过再难 看着看着就会了 加油奥利给

有几个冷知识需要注意

  • synchronized关键字不能继承 你父类的方法synchronized与我子类的super无瓜！
  • 在定义接口方法时不能使用synchronized关键字
  • 构造方法不能使用synchronized关键字，但可以使用synchronized代码块包起来

然后就是这张表了：

修饰内容上锁对象作用对象（互斥体）
代码块（同步代码块）代码调用这个代码块的对象
方法（同步方法）方法调用这个方法的对象
静态方法静态方法（主要是里面的变量）所属类的所有对象实例（静态方法属于类信息）
类括号范围类的所有对象实例

下一节 我们会聊到synchronize怎么结合和wait/notify 机制，解决生产者消费者问题

Java 从多线程到并发编程（七）—— wait notify 生产者消费者问题

阮菜鸡
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java并发编程进阶——并发锁
行者无疆的博客
03-14 4174
1 JAVA 多线程锁介绍 1.1 悲观锁 定义：悲观锁指对数据被外界修改持保守态度，认为数据很容易就会被其他线程修改（很悲观），所以在数据被处理前先对数据进行加锁，并在整个数据处理过程中，使数据处于锁定状态。 悲观锁的实现：开发中常见的悲观锁实现往往依靠数据库提供的锁机制，即在数据库中，在对数据记录操作前给记录加排它锁。如果获取锁失败，则说明数据正在被其他线程修改，当前线程则等待或者抛出异常。如果获取锁成功，则对记录进行操作，然后提交事务后释放排它锁。 实例：Java 中的 synchronized 关键
阿里面试失败后，一气之下我图解了Java中18把锁
热门推荐
华科硕士，大厂打工中。编程问题咨询，请私我
06-17 41万+
目录 乐观锁和悲观锁 独占锁和共享锁 互斥锁和读写锁 公平锁和非公平锁 可重入锁 自旋锁 分段锁 锁升级（无锁|偏向锁|轻量级锁|重量级锁） 锁优化技术（锁粗化、锁消除） 乐观锁和悲观锁 悲观锁 悲观锁对应于生活中悲观的人，悲观的人总是想着事情往坏的方向发展。 举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。 回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程.
全面详解Java并发编程：从基础到高级应用
微笑听雨
05-27 8168
Java并发编程提供了强大的工具和框架，帮助开发者有效管理多线程任务，提升应用程序性能。理解并掌握基本概念、线程管理、同步机制和高级并发工具，并遵循最佳实践，可以编写出高效、安全、可靠的并发程序。
Java进阶 —— 多线程并发
荔枝当大佬的博客
07-25 888
在系统学完Java的面向对象编程之后，我们需要认真地来学习Java并发编程，我们在学习计算机操作系统的时候也都了解过进程、线程和协程的概念。在这篇文章中荔枝主要会梳理有关线程创建、线程生命周期、同步锁和死锁、线程通信和线程池的知识，并给出相应的精简示例，希望能帮助有需要的小伙伴们哈哈哈~~~
Java 从多线程到并发编程（五）—— 线程调度 优先级倒置（反转） 阻塞 死锁 suspend
菜鸡的学习之路
07-15 2644
文章目录 前言 ´･ᴗ･` 线程调度策略 优先级倒置问题 优先级倒置解决方案 死锁 dead lock suspend 被阻塞的同时持有资源不放 是上述问题的诱因 总结 ´◡`
【JVM并发编程专题】——多线程安全——synchronized应用与原理
weixin_44275259的博客
06-03 8898
多线程安全——起源 数据的实效性问题（数据时效过期）：我们知道即使多个线程在同一个进程内可以共享内存数据，但内存共分为工作内存和主内存；工作内存就是，线程的在cpu三级缓存中的内存数据；主内存，就是内存条中分配的内存数据，每一次线程执行对会将主内存的数据复制到工作内存中便于快速访问提供支持，但是如果复制了之后，主内存的数据发生了改变，此时如果你的工作内存中还是以前的数据，那显然业务上是不被允许的，一定要实时同步才可以满足业务严格要求，在java中我们利用volatile关键字实现数据的实时同步，这个关键字
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 1万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
并发编程- java中的锁:Synchronized的四种状态(无锁、偏向锁、轻量级锁、重量级锁)
wang5701071的博客
09-24 4412
Java提供了种类丰富的锁，每种锁因其特性的不同，在适当的场景下能够展现出非常高的效率。 本文介绍的是Synchronized的四种锁状态. 1:什么是Synchronized? Synchronized是java中的关键字,是一种同步锁。它修饰的对象有以下几种：(类, 方法, 代码块) synchronized可以保证方法或代码块在运行时，同一时刻只有一个线程可以进入到临界区（互斥性）所以它也是排它锁，同时它还保证了共享变量的内存可见性。 在JDK1.6版本之前一直被称为''重量级锁'',但是在
深入理解Java并发之synchronized实现原理
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
Java多线程并发编程和锁原理解析
08-25
Java多线程并发编程和锁原理解析是Java并发编程中非常重要的知识点，文章通过示例代码详细介绍了Java多线程并发编程和锁原理解析，对大家的学习或者工作具有一定的参考学习价值。 乐观锁和悲观锁 在Java多线程并发...
深入理解Java多线程与并发编程
08-26
Java多线程与并发编程是Java开发中非常重要的一部分，它涉及到多线程的创建、同步、通信、死锁等问题。下面我们将详细介绍Java多线程与并发编程的相关知识点。 一、多线程三大特性 多线程有三大特性：原子性、可见...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
java多线程编程之使用Synchronized块同步变量
09-04
在Java多线程编程中，`synchronized`关键字是一个至关重要的概念，用于控制并发访问共享资源，以确保数据的一致性和完整性。当我们说"使用`synchronized`块同步变量"时，意味着我们想要确保在同一时间只有一个线程...
Java并发编程实战之互斥锁.pptx
11-13
Java并发编程中的互斥锁是解决多线程环境下原子性问题的关键工具。原子性问题源自于线程在执行过程中可能被CPU切换，导致同一时间多个线程操作共享变量，从而引发数据不一致。为了解决这个问题，我们需要确保对共享...
golang 接口
m0_70982551的博客
07-24 942
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 510
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 634
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 591
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值