java多线程

已于 2022-04-14 00:32:13 修改
阅读量229 收藏
点赞数 1
分类专栏： JAVA多线程 文章标签： java intellij-idea
于 2022-04-14 00:10:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46147033/article/details/124160940
版权

目录

一、线程

1、进程

01.进程特点

02.并发和并行区别

2、线程

3、线程优点

二、线程的创建方式：

1、继承Thread类

2、实现Runnable接口

3、实现Callable接口

4、三种创建线程的比较

三、线程生命周期

四、控制线程手段

1、线程休眠

2、 等待线程

3、后台线程

4、线程优先级

五、有关线程安全

 1.线程不安全示例

2、解决线程安全方法

01、同步代码块

02、同步方法块

03、同步锁

六、死锁

1、死锁示例:

2、解决方法

一、线程

1、进程

* 进程：是处于运行过程中的程序、具有独立的功能、是系统进行资源分配和调度的独立单位

01.进程特点

1、独立性：进程是系统中独立存在的实体，他们拥有自己独立的资源，每个进程都拥有自己私有的抵制空间，在没有经过进程本身允许下、一个进程不能直接访问其他进程的地址空间
2、动态性：进程是一个正在系统中活动的指令集合，包含了时间的概念，具有自己的生命周期状态；
3、并发性：在单个处理器上，多线程可以并发执行，并且在执行时他们彼此之间不会互相的影响。

02.并发和并行区别

并行 ： 在同一时刻，有多条指令在多个处理器上同时执行
并发 ：
        1、在同一时刻，某个处理器只能执行一条指令。
        2、多个进程的指令可以被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果。

2、线程

1、线程扩展进程的概念，使得同一个进程可以同时并发处理多个任务
2、线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程
3、线程不拥有系统资源，他与父线程中的其他线程共享父进程所拥有的全部系统资源

3、线程优点

1、容易共享内存： 进程之间不能够共享内存，但线程之间可以共享内存，因为与分隔的进程相比，线程之间的隔离度比较小，他们共享内存、文件句柄、其他每个进程应有的状态
2、运行效率更高：系统创建进程时候要为其分配系统资源，但创建线程时不需要，所以线程的运行效率更高
3、编程方式简单：JAVA内置了很多多线程功能的支持，并不是简单的对操作系统的底层进行调度，编程更方便。

二、线程的创建方式：

* java的线程模型
        1、JAVA中使用Thread类代表线程，所有的线程对象都是必须是Thread类或子类的实例
        2、线程用于完成一定的任务（执行一段程序流），JAVA使用线程执行体来表示折断程序流
        3、线程的使用过程：定义线程的执行体-->创建线程对象-->调用线程对象的方法启动线程

1、继承Thread类

        1、定义Thread类的子类，并重写该类的run()方法（线程体）。
        2、创建Thread类的子类的实例，即创建线程对象。
        3、调用线程对象的start()方法，启动这个线程。

    public static void main(String[] args) {


        //子线程
        //启动继承与Thread线程
        new First().start();
        new First().start();//线程支持并发，两个线程并发执行

    }
    /**
     * 继承与Thread方式
     */
    private static class First extends Thread{

        @Override
        public void run() {
            //重写线程体
           for (int i = 0; i < 5; i ++){
               System.out.println(Thread.currentThread().getName() + "\t" + i);//输出线程明名
           }
        }
    }

2、实现Runnable接口

1、定义Runnable接口实现类，并实现该接口的run()方法（线程体）
2、创建Runnable实现类的实例，并以此作为target来创建Thread对象
3、调用Thread对象的start()方法启动线程

    public static void main(String[] args){


        //启动实现Runnable接口线程
        new Thread(new Second()).start();
        new Thread(new Second()).start();
    }
    /**
     * 实现Runnable接口
     */
    private static class Second implements Runnable{

        @Override
        public void run() {
            //重写线程体
            for (int i = 0; i < 5; i ++){
                System.out.println(Thread.currentThread().getName() + "\t" + i);//输出线程明名
            }
        }
    }

3、实现Callable接口

1、定义Callable接口实现类，并实现该接口的call()方法（线程体）
2、创建Callable接口的实例，并使用Future接口来包装Callable对象，最后使用Future对象（线程返回值）作为target来创建Thread对象
3、调用Thread对象的start()方法来启动线程
4、调用Future对象的get()方法获取线程的返回值。
public static void main(String[] args) throws ExecutionException, InterruptedException {


        //启动实现Callable接口的线程
        FutureTask<String> task1 = new FutureTask<>(new Third());
        FutureTask<String> task2 = new FutureTask<>(new Third());
        new Thread(task1).start();
        new Thread(task2).start();

  
        //启动实现Callable接口的线程的线程名---采用阻塞方法
        System.out.println("返回值 - 0 ：\t" + task1.get());
        System.out.println("返回值 - 1 ：\t" + task2.get());

    }
 /**
     * 实现Callable接口
     */
    private static class Third implements Callable<String>{

        @Override
        public String call() throws Exception {
            for (int i = 0; i < 5; i ++){
                System.out.println(Thread.currentThread().getName() + "\t" + i);//输出线程明名
            }
            return Thread.currentThread().getName();//返回线程名
        }
    }

4、三种创建线程的比较

* 继承父类的方式：丧失了灵活性
        * 优点：编程简单
        * 缺点：线程类已经继承了Thread类，所以不能在继承其他的父类
* 实现接口的方式
        * 优点：线程类只实现了接口，还可以继承与其他的父类
        * 缺点：编程比较麻烦

三、线程生命周期

* 线程的生命周期
    * 当线程被创建之后，不会立刻进入运行状态，也不会一直处于运行状态。（如果一直运行，就无法实现并发）
    * 线程的生命周期要经过5个状态:
        1、新建（new）
        2、就绪（Ready）
        3、运行（Running）
        4、阻塞（Blocked）
        5、死亡（Dead）
/**
 * 线程生命周期
 */
public class demo2 {
    public static void main(String[] args) throws InterruptedException {
        //启动实现Runnable接口线程

        //新建状态
        Thread thread0 = new Thread(new Second());
        Thread thread1 = new Thread(new Second());
        for (int i = 0; i < 20; i ++) {
            System.out.println(Thread.currentThread().getName() + "\t\t" + i);//输出线程明名
            if (i == 5){
                //子线程就绪状态，等待被调度
                thread0.start();
                thread1.start();
//                thread1.start();//就绪之后再就绪，会报错，只能对新建状态的线程调用start()
                //强制主线程就绪
//                Thread.yield();//不确定强制主线程就绪，
                //设置主线程阻塞,主线程阻塞1ms，使得thread0，和thread1执行
                Thread.sleep(1);
            }
        }


        }
    /**
     * 实现Runnable接口
     */
    private static class Second implements Runnable{

        @Override
        public void run() {
            //重写线程体
            for (int i = 0; i < 5; i ++){
                System.out.println(Thread.currentThread().getName() + "\t" + i);//输出线程明名
            }
        }
    }
}

四、控制线程手段

1、线程休眠

Thread类提供了休眠方法，可以让当前线程暂停一段时间
        1、static void sleep(long millis)
        2、static void sleep(long millis,int nanos)
sleep()与yield()比较
        1、sleep()会让线程进入阻塞状态、而yield()会让线程进入就绪状态
        2、sleep()给其他线程运行机会，不理会其他线程的优先级别，yield()考虑线程的优先级，只会给优先级或者优先级更高的线程执行机会。

2、 等待线程

Thread类提供了等待的方法，可以让调用方等待该线程直至他死亡。
        * void join()
        * void join(long millis)
        * void join(long millis , int nanos)
    public static void main(String[] args) throws InterruptedException {
        newJoinThread();//Join演示

    }

    //Join演示
    private static class JoinThreadTask implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 20; i ++){
                System.out.println(Thread.currentThread().getName() + "\t\t" + i);//输出线程明名
            }
        }
    }

    //创建线程
    public static void newJoinThread() throws InterruptedException {
        //没有Join处理子线程
        new Thread(new JoinThreadTask()).start();
        //主线程
        for (int i = 0; i < 20; i ++){
            System.out.println(Thread.currentThread().getName() + "\t\t" + i);//输出线程明名
            if (i == 10){
                //使用Join方法的子线程
                Thread thread = new Thread(new JoinThreadTask());
                thread.start();
                thread.join();
            }

        }
    }

3、后台线程

* 后台线程、也就守护线程、或者精灵线程。他是在后台运行的，他的任务是为其他线程提供服务的。如果所有的前台线程都死亡，则后台线程会自动死亡
* 线程默认是前台线程，Thread类提供如下方法设置后台线程
        * void() setDaemon(boolean on)
        * boolean inDaemon()
    public static void main(String[] args) throws InterruptedException {

        newDaemoThread();//后台线程

    }



    //后台线程
    private static class DaemonThreadTask implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 200; i ++){
                System.out.println(Thread.currentThread().getName() + "\t\t" + i);//输出线程明名
            }
        }
    }

    public static void newDaemoThread(){
        //创建一个后台线程
        Thread thread = new Thread(new DaemonThreadTask());
        thread.setDaemon(true);//设置后台线程
        thread.start();

        //主线程
        for (int i = 0; i < 20; i ++){
            System.out.println(Thread.currentThread().getName() + "\t\t" + i);//输出线程明名

        }

    }

4、线程优先级

* 线程运行时候拥有优先级，优先级高的线程则拥有较多的运行机会
* 线程默认的优先级与它的父线程相同，而主线程具有普通的优先级
* Thread类提供如下成员处理优先级
        * static int MAX_PRIORITY;
        * static int MIN_PRIORITY;
        * static int NORM_PRIORITY;
        * int getPriority();
        * void setPriority(int newPriority);
    public static void main(String[] args) throws InterruptedException {

        newThreadPriority();//优先级
    }

    //优先级
    private static class priorityThreadTask implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 200; i ++){
                System.out.println(Thread.currentThread().getName() + "\t\t" + i);//输出线程明名
            }
        }
    }

    public static void newThreadPriority(){
        //创建两个线程用于比较优先级
        Thread thread1 = new Thread(new priorityThreadTask());
        Thread thread2 = new Thread(new priorityThreadTask());
        thread1.setPriority(Thread.MAX_PRIORITY);//优先级设置最大
        thread1.start();
        thread2.setPriority(Thread.MIN_PRIORITY);//优先级设置最小
        thread2.start();


    }

五、有关线程安全

 1.线程不安全示例

首先展示一个线程不安全的示例，数据共享场景，以一个假话的抢票系统为例

   /**
     * 线程安全
     */
    //模拟抢票系统
    public static void main(String[] args){
        Ticket ticket = new Ticket(100);//初始化100张票
        //售卖系统
        buyTask task = new buyTask(ticket);
        new Thread(task,"Tom").start();//三者共享同一个数据，共享数据场景
        new Thread(task,"John").start();
        new Thread(task,"Lily").start();
        new Thread(task,"张三").start();
        new Thread(task,"李四").start();
    }
    //设计票数
    private static class Ticket{

        private int amount;//票数
        public Ticket(int amount){//构造器初始化票数
            this.amount = amount;
        }

        //访问数量的方法
        public int getAmount(){
            return amount;
        }

        public void buy(int amount)  {
            if (this.amount < amount){
                throw new IllegalArgumentException("余量不足");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.amount -= amount;
            String name = Thread.currentThread().getName();
            System.out.println(name + "购买成功，剩余票数" + this.amount);
        }

    }

    //卖票
    private static class buyTask  implements Runnable{

        private Ticket ticket;

        public buyTask(Ticket ticket){//构造器
            this.ticket = ticket;
        }

        @Override
        public void run() {
            ticket.buy(1);//每次只能买一张
        }
    }

运行结果，共享数据出现重复

张三购买成功，剩余票数96
Tom购买成功，剩余票数96
Lily购买成功，剩余票数96
李四购买成功，剩余票数96
John购买成功，剩余票数96

2、解决线程安全方法

01、同步代码块

使用synchronized对某一段代码加锁

 public static void main(String[] args) {
        Ticket ticket = new Ticket(100);//初始化100张票
        //售卖系统
        buyTask task = new buyTask(ticket);
        new Thread(task, "Tom").start();//三者共享同一个数据，共享数据场景
        new Thread(task, "John").start();
        new Thread(task, "Lily").start();
        new Thread(task, "张三").start();
        new Thread(task, "李四").start();
    }

    //设计票数
    private static class Ticket {

        private int amount;//票数

        public Ticket(int amount) {//构造器初始化票数
            this.amount = amount;
        }

        //访问数量的方法
        public int getAmount() {
            return amount;
        }

        public void buy(int amount) {
            if (this.amount < amount) {
                throw new IllegalArgumentException("余量不足");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //对之下代码加锁,解决数据共享时候的BUG
            synchronized (this){
                //通过校验成功购票
                this.amount -= amount;
                String name = Thread.currentThread().getName();
                System.out.println(name + "购买成功，剩余票数" + this.amount);
            }
        }

    }

    //卖票
    private static class buyTask implements Runnable {

        private Ticket ticket;

        public buyTask(Ticket ticket) {//构造器
            this.ticket = ticket;
        }

        @Override
        public void run() {
            ticket.buy(1);//每次只能买一张
        }
    }

运行结果

John购买成功，剩余票数99
李四购买成功，剩余票数98
Tom购买成功，剩余票数97
张三购买成功，剩余票数96
Lily购买成功，剩余票数95

Process finished with exit code 0

02、同步方法块

在方法上加synchronized，此方法比同步代码块差，因为加锁范围增大大，加锁后性能降低
   public static void main(String[] args) {
        Ticket ticket = new Ticket(100);//初始化100张票
        //售卖系统
        buyTask task = new buyTask(ticket);
        new Thread(task, "Tom").start();//三者共享同一个数据，共享数据场景
        new Thread(task, "John").start();
        new Thread(task, "Lily").start();
        new Thread(task, "张三").start();
        new Thread(task, "李四").start();
    }

    //设计票数
    private static class Ticket {

        private int amount;//票数

        public Ticket(int amount) {//构造器初始化票数
            this.amount = amount;
        }

        //访问数量的方法
        public int getAmount() {
            return amount;
        }

        public synchronized void buy(int amount) {
            if (this.amount < amount) {
                throw new IllegalArgumentException("余量不足");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.amount -= amount;
            String name = Thread.currentThread().getName();
            System.out.println(name + "购买成功，剩余票数" + this.amount);
        }

    }

    //卖票
    private static class buyTask implements Runnable {

        private Ticket ticket;

        public buyTask(Ticket ticket) {//构造器
            this.ticket = ticket;
        }

        @Override
        public void run() {
            ticket.buy(1);//每次只能买一张
        }
    }

运行结果

John购买成功，剩余票数99
李四购买成功，剩余票数98
Tom购买成功，剩余票数97
张三购买成功，剩余票数96
Lily购买成功，剩余票数95

Process finished with exit code 0

03、同步锁

最优解，灵活性高，可以实现读写锁分离
public static void main(String[] args) {
        Ticket ticket = new Ticket(100);//初始化100张票
        //售卖系统
        buyTask task = new buyTask(ticket);
        new Thread(task, "Tom").start();//三者共享同一个数据，共享数据场景
        new Thread(task, "John").start();
        new Thread(task, "Lily").start();
        new Thread(task, "张三").start();
        new Thread(task, "李四").start();
    }

    //设计票数
    private static class Ticket {
        private Lock lock = new ReentrantLock();//实例化锁对象

        private int amount;//票数

        public Ticket(int amount) {//构造器初始化票数
            this.amount = amount;
        }

        //访问数量的方法
        public int getAmount() {
            return amount;
        }

        public void buy(int amount) {
            if (this.amount < amount) {
                throw new IllegalArgumentException("余量不足");
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            lock.lock();//表示在此处加锁
            try{
                this.amount -= amount;
                String name = Thread.currentThread().getName();
                System.out.println(name + "购买成功，剩余票数" + this.amount);
            }finally {
                lock.unlock();//解锁
            }
        }

    }

    //卖票
    private static class buyTask implements Runnable {

        private Ticket ticket;

        public buyTask(Ticket ticket) {//构造器
            this.ticket = ticket;
        }

        @Override
        public void run() {
            ticket.buy(1);//每次只能买一张
        }
    }

运行结果

John购买成功，剩余票数99
李四购买成功，剩余票数98
Tom购买成功，剩余票数97
张三购买成功，剩余票数96
Lily购买成功，剩余票数95

Process finished with exit code 0

*  以上三种方法是通过加锁方式实现共享数据时候的线程安全问题

六、死锁

当两个线程互相等待对方释放同步监视器时候会发生死锁。


1、死锁示例:

 public static void main(String[] args) {
        String a = "A";
        String b = "B";
        new Thread(new FristTask(a,b)).start();
        new Thread(new SercodTask(a,b)).start();
    }
    private static class FristTask implements Runnable{

        private Object a;
        private Object b;
        public FristTask(Object a,Object b){//构造器初始化a，b
            this.a = a;
            this.b = b;
        }
        @Override
        public void run() {
            synchronized (a){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b){
                    System.out.println("First");
                }

            }
        }
    }
    private static class SercodTask implements Runnable{

        private Object a;
        private Object b;
        public SercodTask(Object a,Object b){//构造器初始化a，b
            this.a = a;
            this.b = b;
        }
        @Override
        public void run() {
            synchronized (b){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (a){
                    System.out.println("First");
                }

            }
        }
    }

程序一直运行，不会输出

2、解决方法

* 避免多次死锁 ： 尽量避免同一个线程对多个同步监视器进行锁定

* 按相同的顺序加锁 ： 如果多个线程需要对多同步监视器加锁，则应该保证他们以相同的顺序请求加锁

* 使用可以超时释放的锁 ： 调用Lock()对象的tryLock(time,unit)方法，当超过指定的时间后他会自动释放锁

Mr_Fan99
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
java的多线程
Myzhujie的博客
07-07 1014
多线程
java多线程（超详细）
热门推荐
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
java多线程使用教程
鹏鹏2077
04-25 5197
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 971
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 925
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 892
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
Java解决最长公共前缀
无人罪的博客
04-28 244
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 471
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 911
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
Spring cloud原理详解
qq_33449977的博客
04-28 354
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
最新发布
qq_43209531的博客
04-30 259
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 842
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值