【JavaSE】多线程基础-概述

最新推荐文章于 2024-10-09 23:44:37 发布
最新推荐文章于 2024-10-09 23:44:37 发布
阅读量835 收藏 22
点赞数 15
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63834571/article/details/139021773
版权

Catalog

多线程基础

1. 程序、进程&线程

  1. 程序：为完成某个特定任务，用某种语言编写的一组指令集合，即一段静态的代码段。
  2. 进程：即运行的程序就是进程，进程可以理解为动态的程序，是操作系统分配和调用资源的最小单位。
  3. 线程：进程进一步细化则是线程，线程可以理解为进程中的一条工作路径，比如点开某个软件（相当于开启了一个进程），同时开启该软件中的多个功能，相当于开启了多个线程，如百度网盘中，同时开启多个下载任务，即相当于开启了多个线程。
  4. 进程和线程之间的关系：只有当一个进程中的所有线程都结束了，这个进程才会结束。

Alt

2. 并行和并发

  1. 并行：同一时刻，多个任务交替执行。单个cpu执行多项任务，即cpu在多个任务间快速切换执行，形成貌似在同时执行多个任务的样子。
  2. 并发：同一时刻，多个任务同时实行。多个cpu在同一时刻各自执行自己的任务。
  3. 说明：并行中也可能包含并发，如开启了后台很多任务时，多个并行的cpu也需要交替执行多个任务（并发）。

3. 开启线程的底层方法

Thread类中的run方法只是一个普通的方法，真正开启线程的方法是Thread类中的start()方法中的本地方法start0(),该方法由虚拟机调用，涉及到操作的系统的IO资源等的调用。

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

4. 创建线程的两种方式

  1. 继承Thread类，实现run()方法，调用start()方法开启线程：

    public class Thread01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.start();
    }
}


class Dog extends Thread {

    int time = 0;

    @Override
    public void run() {

        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println("旺旺旺" + ++time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }


}

  2. 实现Runnable接口，实现run()方法，通过Thread类静态代理，开启线程：

    public class Thread02 {

    public static void main(String[] args) {
        Computer computer = new Computer();
        //通过Thread类静态代理，开启线程
        Thread thread = new Thread(computer);
        thread.start();
        System.out.println("main .... ");
    }

}

class Computer implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " " +"begin to running");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

5. 线程终止

让线程终止一般有两种方式：

  1. 线程执行完任务（代码语句）后，会自动结束线程；

  2. 通知线程结束，如通过控制一个变量结束线程中的run方法，即可终止线程，demo如下：

    public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        Thread01 thread01 = new Thread01();

        //开启线程
        thread01.start();

        //让主线程沉睡，给线程多一些运行的时间
        Thread.sleep(20 * 1000);

        //通过修改变量，控制线程退出--通知方式
        thread01.setLoop(false);

    }

}


class Thread01 extends Thread {

    int time = 0;

    //设置变量,控制线程退出
    private boolean loop = true;


    @Override
    public void run() {

        while (loop) {
            try {
                Thread.sleep(50);
                System.out.println("run..." + ++time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

        System.out.println(Thread.currentThread().getName() + ": 线程终止");

    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

6. Thread类中常用的API

方法描述
start()用于启动线程并调用run()方法，使线程进入就绪状态。
run()定义了线程的操作，会在新线程中执行。
sleep(long millis)使当前线程暂停执行一段时间，让其他线程有机会继续执行。
join()允许一个线程等待另一个线程完成其执行。
interrupt()用于中断正在执行的线程，向线程发送一个中断信号，一般用于中断线程的休眠。
isAlive()用于检查线程是否还活着。
setPriority(int priority)用于设置线程的优先级。
yield()使当前线程放弃CPU并允许其他线程运行,当系统资源较充足的时候，可能会放弃失败。

Demo: 中断线程休眠

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException{
        //创建一个线程对象
        Eat eat = new Eat();

        //设置线程名字
        eat.setName("Amin");

        //设置线程优先级
        eat.setPriority(Thread.MIN_PRIORITY);

        //开启线程
        eat.start();

        //主线程通知Eat线程中断睡眠
        for (int i = 0; i < 3; i++) {
            Thread.sleep(1000);
            System.out.println("Hi " + eat.getName());
        }

        //中断线程
        eat.interrupt();

    }

}

class Eat extends Thread{

    int times = 0;

    @Override
    public void run() {
        while (true){

            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName() + "吃饺子..." + i);
            }

            //线程沉睡
            try {
                Thread.sleep(20 * 1000);
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " is interrupted ...");
            }


        }
    }
}

demo2: 协调线程

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        //创建线程对象
        ThreadHighLevel threadHighLevel = new ThreadHighLevel();

        threadHighLevel.start();

        for (int i = 0; i < 20; i++) {
            Thread.sleep(1000);
            System.out.println("main:" + "hi" + " -> " + i);
            if (i == 4){
                System.out.println("开始暂停...");
                //直接让线程插队
                threadHighLevel.join();
                //根据系统资源是否充足，礼让别的线程（让出cpu）
                //Thread.yield();
            }


        }
    }
}

class ThreadHighLevel extends Thread{

    int times = 0;

    @Override
    public void run() {
        while (times < 20){
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + ":hello" + times);
                times++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }


    }
}

7. 多线程可能出现的问题

同步互斥问题

线程同步，即多个线程操作同一内存（数据）时，同一时刻，只允许一个线程对数据进行修改，该线程退出后，才能由下一个线程进行修改。

  1. 多线程同步导致数据异常，即多线程操作同一内存，导致数据发生异常。
public class BookingOffice {
    public static void main(String[] args) {
        //模拟互斥同步现象

        //创建3个线程，即同时售卖票
        SellingTicket01 sellingTicket01 = new SellingTicket01();
        SellingTicket01 sellingTicket02 = new SellingTicket01();
        SellingTicket01 sellingTicket03 = new SellingTicket01();

        //开启线程
        sellingTicket01.start();
        sellingTicket02.start();
        sellingTicket03.start();

    }
}


class SellingTicket01 extends Thread{

    //创建静态变量，让多个线程共享，--票剩余数量
    public static Integer ticketNumber = 100;

    @Override
    public void run() {
        //模拟买票的场景
        try {
            while (true){
                //1. 判断票数是否为0
                if (ticketNumber == null || ticketNumber <= 0){
                    System.out.println("售票结束...");
                    break;
                }

                Thread.sleep(50);

                //2. 开始售出票
                System.out.println(Thread.currentThread().getName() + ":售出一张票， " + "剩余票数为：" + (--ticketNumber));

            }


        } catch (InterruptedException e) {
            e.printStackTrace();
        }




    }
}
  1. 超卖现象

Alt

  1. 原因分析

比如票数只剩余1张或者两张的这一时刻，三个线程同时通过了售空退出循环的判断，导致三个线程都能够对票数–，出现负数。

  1. 解决方案：
    可以在需要同步的代码块或者方法上添加sychronized关键字，即给代码块或者方法添加了一个对象互斥锁（通过改变同一对象的某个位实现加锁）。

    • 代码块：可以是静态代码块和普通代码块，前者需要绑定当前类，后者需要绑定同一对象（Object类对象都可以），绑定代码块的使用场景更广泛，因为代码块限制的范围更小，同步代码越少，程序执行效率一般会更高。
    • 方法：可以是静态方法或者是实例方法，前者需要绑定当前类，后者需要绑定同一对象（Object类对象都可以）。

    抽离出买票代码，封装成实例方法，添加synchronized关键字，设置为同步方法

    public class BookingOffice {
    public static void main(String[] args) {
        //模拟互斥同步现象

      /*  //创建3个线程，即同时售卖票
        SellingTicket01 sellingTicket01 = new SellingTicket01();
        SellingTicket01 sellingTicket02 = new SellingTicket01();
        SellingTicket01 sellingTicket03 = new SellingTicket01();

        //开启线程
        sellingTicket01.start();
        sellingTicket02.start();
        sellingTicket03.start();*/

        //实现Runnable接口开启线程，目的为让三个线程调用同一个run方法
        SellingTicket02 sellingTicket021 = new SellingTicket02();


        new Thread(sellingTicket021).start();
        new Thread(sellingTicket021).start();
        new Thread(sellingTicket021).start();


    }
}


class SellingTicket01 extends Thread{

    //创建静态变量，让多个线程共享，--票剩余数量
    public static Integer ticketNumber = 100;

    @Override
    public void run() {
        //模拟买票的场景
        try {
            while (true){
                //1. 判断票数是否为0
                if (ticketNumber == null || ticketNumber <= 0){
                    System.out.println("售票结束...");
                    break;
                }

                Thread.sleep(50);

                //2. 开始售出票
                System.out.println(Thread.currentThread().getName() + ":售出一张票， " + "剩余票数为：" + (--ticketNumber));

            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

class SellingTicket02 implements Runnable{

    //使用的为同一个对象,不需要创建静态变量，让多个线程共享，--票剩余数量
    public Integer ticketNumber = 100;

    public boolean loop = true;

    public synchronized void sell(){
        //模拟买票的场景
        try {
                //1. 判断票数是否为0
                if (ticketNumber == null || ticketNumber <= 0){
                    System.out.println("售票结束...");
                    loop = false;
                    return;
                }

                Thread.sleep(50);

                //2. 开始售出票
                System.out.println(Thread.currentThread().getName() + ":售出一张票， " + "剩余票数为：" + (--ticketNumber));


        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    /**
     * 不能直接在run方法上面添加synchronize关键字，因为run方法中while中的代码才是执行逻辑，直接添加会导致只有一个线程能够进行买票。
     */
    @Override
    public void run() {
        while (loop){
            sell();
        }
        
    }
}

    Demo

     //1. 同步静态代码块
    static{
        synchronized (SellingTicket02.class){
            System.out.println("同步静态代码块");
        }
    }


    public void m1(){
        //2. 同步代码块,注意在方法中才可以使用,这里使用的this关键字，也可以替换成其它对象
        synchronized (this){
            System.out.println("同步代码块");
        }
        
    }
    
    //3. 静态同步方法
    public synchronized static void m2(){
        System.out.println("静态同步方法");
    }
    
    //4. 同步实例方法
    public synchronized void m3(){
        System.out.println("同步实例方法");
    }

    死锁

    ​ 在多线程中，可能会出现两个线程互相等待获取对方资源的场景，即一个线程优先拿到了一个锁A，另一个线程拿到了锁B，而第一个线程需要再获取一个资源（这个资源需要锁B）才能进行下一步，第二个线程也需要再获取一个资源（这个资源需要锁A)才能进行下一步，从而出现两个线程相互等待，导致整个程序无法执行下一步。

    • 出现场景：一般出现在某些线程需要获取多把锁的情况。

    Demo（老韩）

    public class DeadBlock01 {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A 线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B 线程");
        A.start();
        B.start();
    }
}
//线程

class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用 static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {//构造器
        this.flag = flag;
    }

    @Override
    public void run() {
        //下面业务逻辑的分析
        //1. 如果 flag 为 T, 线程 A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        //2. 如果线程 A 得不到 o2 对象锁，就会 Blocked
        //3. 如果 flag 为 F, 线程 B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
        //4. 如果线程 B 得不到 o1 对象锁，就会 Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入 1");
                synchronized (o2) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 2");
                }
            }
        } else {

            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入 3");
                synchronized (o1) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 4");
                }
            }
        }
    }
}

8. 用户线程&守护线程

  1. 用户线程：即工作线程，上述通过Thread类创建的普通线程就是工作线程；

  2. 守护线程：守护线程是为工作线程服务的，守护线程的特点就是，当所有用户进程结束之后，守护线程会自动退出。

    • 常见的守护线程应用场景：监控线程、垃圾回收机制…

    • 使用方法：调用daemon（）方法设置为true,即可将调用方的线程设置为守护线程。

       //创建线程对象
        ThreadHighLevel threadHighLevel = new ThreadHighLevel();
            
        //注意设置守护线程，需要在开启线程之前（即调用start方法之前）
        threadHighLevel.setDaemon(true);
        
        threadHighLevel.start();

9. 线程的生命周期（虚拟机）

在Java虚拟机中，线程的生命周期可以分为七个（注意是在虚拟机中，并非是操作系统中关于线程的所有状态）。

  1. NEW:即新建状态，对应到代码阶段，就是创建了一个线程对象（Thread类）。
  2. RUNNABLE:即可运行状态，这个状态可以细分为两个状态，这两个状态之间的切换设计到底层的操作系统，即内核态关于线程的调度。
    • Ready:即就绪态，这时线程并没有真正开始运行。
    • running:即运行态，这时候，线程开始真正地运行。
  3. TIMED_WAITING:指定一个时间段，一般为等待另一个线程完成一些特定的操作，然后重新进入RUNNABLE状态。
  4. WAITING:线程无限期地等待。
  5. BLOCK:即线程的阻塞状态，这里涉及到加锁等方面的内容。
  6. TERMINATED:即线程处于终止状态。

状态图（韩老师）

Alt

Demo：查看线程的一些状态

public class ThreadState {
    public static void main(String[] args) throws InterruptedException{
        ThreadStateExample threadStateExample = new ThreadStateExample();

        Thread thread = new Thread(threadStateExample);
        //查看线程状态
        System.out.println(thread.getName() + "'s state: " + thread.getState());

        //开启线程
        thread.start();
        System.out.println(thread.getName() + "'s state: " + thread.getState());


        while (thread.getState() != Thread.State.TERMINATED){
            //main线程沉睡
            Thread.sleep(500);
            System.out.println(thread.getName() + "'s state: " + thread.getState());
        }


    }
}


class ThreadStateExample implements Runnable{
    @Override
    public void run() {

        int times = 20;

        while (times > 0){
            
            try {
                System.out.println(Thread.currentThread().getName() + ": 吃饭、睡觉、打豆豆");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            times--;

        }


    }
}

10. 释放锁

释放锁，一般是指线程拿到锁，使用完资源之后，归还锁，让该资源能够让别的线程使用。

场景

  • 线程使用完资源：同步代码块执行完（或者遇到break、return关键字、出现error和异常）。
  • 执行了线程对象中的wait()方法。

细节

  • 线程睡眠不会释放锁
指数反对数
关注
专栏目录
JavaSE --- 多线程
MemoryTa的博客
08-06 277
多线程。。概述生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产者消费者问题，实际上主要是包含了两类线程：一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为Object类的等待和唤醒方法。............
javase基础自学笔记-java开端-概述
05-07
Java的特点包括简单性、面向对象、健壮性、安全性、高性能、可移植性、多线程和动态性。学习Java SE基础，你需要掌握基本语法、数据类型、控制结构、类和对象等概念。 "Java中public class与class的区别"是一个关键...
JavaSE自学基础---多线程1
真正的大师,永远都怀着一颗学徒的心----易大师
02-15 264
多线程概述 进程 : 是一个正在执行中的程序 每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫控制单元 线程 : 就是进程中的一个独立的控制单元,线程在控制进程的执行 一个进程中至少有一个线程 java虚拟机启动的时候会有一个进程java.exe 该进程至少有一个线程负责java程序的执行 而且这个线程运行的代码存在于main方法中 该线程称为主线程. 扩展 : 其实jvm运行不止有...
JavaSE笔记7.1-多线程-概述
qq_38503984的博客
02-04 1221
一. 进程和线程 进程：是一个正在执行中的程序。 每一个进程执行都有一个执行的顺序，该顺序就是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。 线程在控制着进程的执行。 一个进程中至少有一个线程。 二. Java的运行进程 javac.exe：Java的编译进程 java.exe：Java的运行进程 Java JVM启动的时候会有一个进程java.exe 该进程中至少有...
1. JavaSE-多线程基础知识
weixin_45267102的博客
10-20 526
Java使用java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。
JavaSE进阶知识学习----多线程基础知识-1
疾风知劲草，智者必怀仁
01-26 350
多线程基础知识 1.概述程序，进程和线程 程序：是为了完成某一特定的功能或任务，用某种语言编写的一段静态代码。 进程：是程序的一次执行过程，它自身有产生，存在和消亡的生命周期。 线程：是进程的小单元，是一个程序内部的一条执行路径。 2.Java中多线程的创建和使用 2.1线程的创建方法之一：继承Thread类，重写Run()方法。 使用说明： 1.定义子类继承Threa
JAVASE基础 Item -- 多线程，并发
小平果的欢乐谷
02-27 3021
一、多线程概述1:要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在。2:什么是进程? 通过任务管理器我们就看到了进程的存在。 而通过观察，我们发现只有运行的程序才会出现进程。 进程：就是正在运行的程序。 进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。3:多进程有什么意义呢?
javaSE-----java概述
sinat_50855580的博客
12-01 352
1.java概述 1.1.java是什么？ Java是一门面向对象编程语言[程序设计语言].不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 1.2.面向对象是什么？它的基本特征是什么？ 面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界
Java基础进阶多线程概述
qq_46096136的博客
09-11 6416
CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情。不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于。线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在。我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。人类的眼睛产生了错觉，感觉是动画的。一个是垃圾回收线程，一个是执行main方法的主线程。
JavaSE进阶知识学习----多线程基础知识
阿杰同学的博客
02-15 195
多线程基础知识 1.概述程序，进程和线程 程序：是为了完成某一特定的功能或任务，用某种语言编写的一段静态代码。 进程：是程序的一次执行过程，它自身有产生，存在和消亡的生命周期。 线程：是进程的小单元，是一个程序内部的一条执行路径。 2.Java中多线程的创建和使用 2.1线程的创建方法之一：继承Thread类，重写Run()方法。 使用说明： 1.定义子类继承Thread类。 2.子类中重写Thread类中的run方法。 3.创建Thread子类对象，即创建了线程对象 4.调用线程对象的start方法，启动
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1214
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 357
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 522
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Netty 相比原生IO模型的优势
lssffy的博客
10-09 335
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1355
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
Apache Flink Dashboard
最新发布
qq_41081716的博客
10-09 230
并行度，可以运行一个任务实例。已完成、取消和失败的作业数量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值