线程

最新推荐文章于 2024-10-17 19:11:48 发布
最新推荐文章于 2024-10-17 19:11:48 发布
阅读量116 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54241718/article/details/114090237
版权

线程

程序：完成特定任务，用某种语言编写的一段静态代码

进程：正在运行的程序，进程作为资源分配的单位，系统在运行时为每个进程分配了不同的内存域

线程：程序内部的一条执行路径，线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器

​

并行：多个CPU执行不同的任务，例如多个人执行不同的任务

并发：一个CPU（采用时间片的方式)同时执行多个不同的任务，多个人做同一件事，比如一千个人秒杀一台手机。

多线程的创建方式(四种)
①继承Thread类

​ 1.创建一个继承于Thread类的子类

​ 2.在子类中重写Thread的run方法，该方法里面写线程执行的操作

​ 3.创建该子类的对象

​ 4.用该子类对象调用start()方法，该方法是父类中的方法

public class Thread1Test {
    public static void main(String[] args) {
        /**
         * 一个已经执行start的线程不能用同一个线程启动第二次，需要新创建一个线程来启动
         * */
        MyThread1 myThread1=new MyThread1();
        MyThread1 myThread2=new MyThread1();
        myThread1.start();
        myThread2.start();
        System.out.println("hello");
    }
}
class MyThread1 extends Thread{
    /**
     * 线程逻辑业务
     * */
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
Thread里面的方法

①run():线程子类重写Thread的方法，该方法里面放线程里面需要执行的逻辑业务

②start()：线程子类对象启动线程的方法

③currentThread()：静态方法，获取当前线程

④getName()：获取当前线程的名字

⑤setName()：设置当前线程的名字

⑥yield()：释放当前cpu执行该线程的执行权

⑦join()：在线程a中调用线程b的方法，此时线程a进入了阻塞状态，只有等线程b执行完后，线程a才 阻塞。

⑧sleep()：让进程休眠一段时间，进入阻塞状态

public class ThreadMethodTest {
    public static void main(String[] args) {
        MyThread12 myt1=new MyThread12();
        MyThread13 myt2=new MyThread13();
        myt1.setName("线程一");
        myt2.setName("线程二");
        myt1.start();
        myt2.start();
        for (int i = 0; i <50 ; i++) {
            /**
             * 调用join方法
             * */
            if(i==20){
                try {
                    myt1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if(i==30){
                try {
                    myt2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("主线程*********"+i);
        }
    }
}
class MyThread12 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            /**
             * 调用sleep方法，让进程进入阻塞状态
             * */
            if(i==50){
                try {
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
class MyThread13 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <50 ; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
线程调度
调度策略

①时间片

②抢占式：高优先级的线程抢占CPU

线程优先级等级

MAX_PRIORITY:10

NORM_PRIORITY:5

MIN_PRIORITY:1

线程优先级的获取和设置

getPriority()：Thread.currentThread.getPriority()

setPriority()

②实现Runnable接口

​ 1.创建一个实现runnable接口的类

​ 2.重写接口中的run()方法

​ 3.创建线程子类的对象

​ 4.将该对象以参数的形式传入Thread构造器当中，并创建Thread对象

​ 5.用Thread对象调用start()方法

public class Thread2Test {
    public static void main(String[] args) {
        //第三步：创建线程子类对象
        WindowSail win1=new WindowSail();
        //第四步：创建Thread对象，并将线程子类对象以参数形式传入Thread构造器中
        Thread th1 = new Thread(win1);
        Thread th2 = new Thread(win1);
        th1.setName("窗口1");
        th2.setName("窗口2");
        th1.setPriority(Thread.MAX_PRIORITY);
        //第五步：调用start方法
        th1.start();
        th2.start();
    }
}
//第一步：实现runnable接口
class WindowSail implements Runnable{
    private int ticket=100;
    //第二步：重写run方法
    @Override
    public void run() {
       while (true){
           if(ticket>0){
               System.out.println(Thread.currentThread().getName() + "取票：" + ticket);
               ticket--;
           }else {
               break;
           }
       }
    }
}

​ 

Thread.class

//run（）方法
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

//Thread中的构造方法
public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

比较创建线程的两种方式

开发中：优先选择→实现Runnable接口的方式

​ 原因：①、实现方式没有类的单继承的局限性

​ ②、实现的方式更适合来处理多个线程有共享数据的情况

联系：都用到了Thread类，并且Thread实现了Runnable接口

​ 两种方式都需要重写run()方法，将线程要执行的逻辑声明在run()中

③实现Callable

​ 1)相比Runnable于run方法，该重写方法call（）有返回值

​ 2）可以抛异常，被外面的操作捕获

​ 3）可以支持泛型

public class CallableThreadTest {
    public static void main(String[] args) {
        //3.创建Callable实现类的对象
        CallableWindow calw=new CallableWindow();
        //4.创建FutureTask对象，并将实现类对象以参数形式传入FutureTask的构造器中
        FutureTask futureTask1 = new FutureTask(calw);
        FutureTask futureTask2 = new FutureTask(calw);
        //5.将FutureTask对象以参数形式传入Thread构造器中，并调用Start方法
        new Thread(futureTask1).start();
        new Thread(futureTask2).start();
        try {
            //get获得的返回值就是FutureTask构造器参数Callable实现类重写方法call的返回值
            Object o = futureTask1.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//1.创建实现Callable接口的实现类
class CallableWindow implements Callable{
    private int ticket=100;
    //2.重写call方法
    @Override
    public Object call() throws Exception {
        while (true) {
            synchronized(this){
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName() + "正在出票" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
        return null;
    }
}
④创建线程池方式
public class ThreadPoolTest {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}
线程生命周期

EL1K8S1XVK4SBFHH

解決线程安全的方法→同步机制
方式一：同步代码块
synchronzied(同步监视器){

//需要被同步的代码

}

说明：1。操作共享数据的代码，即为需要被同步的代码

​ 2.共享数据：多个线程共同操作的变量。比如抢票中的车票就是共享数据

​ 3.同步监视器，俗称锁，任何一个类的对象，都可以充当锁。

​ 要求：多个线程必须要使用同一把锁，也就是用作锁的实例对象只能创建一次

public class ThreadSynchronized {
    public static void main(String[] args) {
        WindowSynchronized winS11=new WindowSynchronized();
        winS11.start();
        WindowSynchronized winS12=new WindowSynchronized();
        winS12.start();
        //*****
        WindowSynchronized winS2=new WindowSynchronized();
        Thread thread1=new Thread(winS2);
        Thread thread2=new Thread(winS2);
        thread1.start();
        thread2.start();
    }
}
class WindowSynchronized extends Thread{
    private static int ticket=100;
    /**
     * 这里由于继承Thread类方式如果多线程调用的话是创建多个线程子类对象，那么object就不唯一了
     * 而锁是需要唯一，因此需要用static，这个锁可以是任何一个对象，并不一定要object比如可以创
     * 建一个Dog对象
     * */
    private static Object object=new Object();
    @Override
    public void run() {
        while (true){
            /**
             * 这里除了可以用object这个锁之外，还可以用WindowSynchronized.class,这里用到了
             * 反射知识，Class clazz=WindowSynchronized.class,这也是个对象，即类本身也是对
             * 象
             * synchronized(WindowSynchronized.class){}
             * */
            synchronized (object){
                if(ticket>0){
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}
/**
* 实现Runnable接口方式
* */
class WindowSynchronized2 implements Runnable{
    private int ticket=100;
    /**
     * 这里不用static是由于在调用时候只创建了WindowSynchronized2一次对象，所以对象锁是唯一的
     * */
    private Object object=new Object();
    @Override
    public void run() {
        while (true){
            /**
             * 这里也可以用object方式
             * */
            synchronized (this){
                if(ticket>0){
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}
方式二：同步方法

1.同步方法仍然需要用到同步监视器，知识不需要我们显示的声明

2.非静态的同步方法，同步监视器是this

​ 静态的同步方法，同步监视器是当前类本身

public class SynchronizedMethod {
    public static void main(String[] args) {
        WindowRunnable winr=new WindowRunnable();
        Thread th1=new Thread(winr);
        Thread th2=new Thread(winr);
        th1.start();
        th2.start();
        //Thread方法
        WindowThread wint=new WindowThread();
        WindowThread wint1=new WindowThread();
        wint.start();
        wint1.start();
    }
}
/**
 * 实现Runnable方式的同步方法
* */
class WindowRunnable implements Runnable{
    private int ticket=100;

    @Override
    public void run() {
        while (true){
            sail();
        }
    }
    /**
     * 这里的同步监视器(锁)就是this，当前对象
     * */
    private synchronized void sail(){
        if(ticket>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + ticket);
            ticket--;
        }
    }
}
/**
 * 继承Thread类的方式
 * */
class WindowThread extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
            sail();
        }
    }
    /**
     * 这里的同步监视器是WindowThread.class类对象，而且这里一定要有static
     * */
    private static synchronized void sail(){
        if(ticket>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":" + ticket);
            ticket--;
        }
    }
}

方式三：Lock锁

class WindowLock implements Runnable{
    private int ticket=100;
    private ReentrantLock lock=new ReentrantLock();
    //第二步：重写run方法
    @Override
    public void run() {
        while (true){
            /**
             * 这个lock一定是紧跟try前面，并且调用lock方法之后一定要调用unlock方法，并且
             * 这个unlock方法一定是在finally第一行
             * */
            lock.lock();
            try {
                if(ticket>0){
                    if(ticket==20){
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName() + "取票：" + ticket);
                    ticket--;
                }else {
                    break;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}
同步机制解决单例模式(懒汉式)线程安全
class Bank{
    private static Bank instance=null;
    /**
     * 同步代码块方式
     * */
    public static Bank getInstance(){
        if(instance==null){
            synchronized (Bank.class){
                if(instance==null){
                    instance=new Bank();
                }
            }
        }
        return instance;
    }
    /**
     * 同步方法方式
     * */
    public static synchronized Bank getInstance1(){
        if(instance==null){
            instance=new Bank();
        }
        return instance;
    }
}
线程通信间使用到的两个方法
1.wait()

​ 一旦调用了wait方法，那么当前线程就会进入阻塞状态，并且释放同步监视器（锁）

​ 调用notify（）方法会唤醒被wait的线程，如果多个线程被wait()，那么会唤醒优先级高的那个

​ 调用notifyAll()方法会唤醒所有被wait的方法

2.sleep()

​ 一旦执行此方法，线程会进入阻塞状态

wait()和slee（）方法的异同

同：这两个方法都可以使当前线程进入阻塞状态

不同：1）两个方法的位置不同，wait()是在java.lang.Object中，而sleep()是在Thread中。

​ 2）调用的要求不同，sleep可以在任何场景下被调用，但是wait()只能在同步代码或者同步方法

​ 中被调用

​ 3)关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep不会释放 同步监视器，而wait()一旦被调用就会释放当前线程的所拥有的锁，被其它线程所获得，其它 线程调用notify后会将wait的线程所唤醒，结束阻塞状态。

生产者消费者模型
public class ProductConsumerTest {
    public static void main(String[] args) {
        Product product=new Product();
        Producer producer=new Producer(product);
        Consumer consumer=new Consumer(product);
        Thread thpro=new Thread(producer);
        Thread thcon=new Thread(consumer);
        thpro.setName("生产者");
        thcon.setName("消费者");
        thpro.start();
        thcon.start();
    }
}
class Product{
    private int productor=0;
    public synchronized void productShow() {
        if(productor<20){
            productor++;
            System.out.println(Thread.currentThread().getName() + "在生产第" + productor + "个产品");
            //唤醒消费者，说明可以开始消费了
            notify();
        }else {
            /**
             * 这里是当生产者生产的产品超过了20个，那么就要进入阻塞状态，不能继续生产了，只有等着
             * 消费者消费一个之后那么就还可以生产，由于此时生产者进入了阻塞状态，那么只有靠消费者
             * 调用notify来唤醒生产者，反过来，生产者唤醒消费者同样原理
             * */
            try {
                wait(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumerShow() {
        if(productor>0){
            System.out.println(Thread.currentThread().getName() + "正在消费第" + productor + "个产品");
            productor--;
            notify();
        }else {
            try {
                wait(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer implements Runnable{
    Product product;

    public Producer(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        System.out.println("生产者开始生产产品了");
        while (true) {
            product.productShow();
        }
    }
}
class Consumer implements Runnable{
    Product product;

    public Consumer(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        System.out.println("消费者开始消费产品了");
        while (true){
            product.consumerShow();
        }
    }
}
死锁问题

多线程间都在等待对方的和自己的同步资源，它不会报异常，只是所有线程都处于阻塞状态。

解决方法

​ 1.专门的算法、原则

​ 2.尽量减少同步资源的定义

​ 3.尽量避免嵌套同步

风淡了伤
关注
专栏目录
多线程面试题（值得收藏）
tanmomo的博客
08-16 21万+
史上最强多线程面试47题(含答案)，建议收藏 金九银十快到了，即将进入找工作的高峰期，最新整理的最全多线程并发面试47题和答案总结，希望对想进BAT的同学有帮助,由于篇幅较长，建议收藏后细看~ 1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修...
JAVA线程
互联网底层民工的博客
06-26 9773
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
如何获取多线程执行结果-java
二十同学
08-12 1万+
在日常的项目开发中，我们会经常遇到通过多线程执行程序并需要返回执行结果的场景，下面我们就对获取多线程返回结果的几种方式进行一下归纳，并进行简要的分析与总结。 一、Thread.join 在一些简单的应用场景中我们可以使用线程本身提供的join方法，我们知道join方法的目的是让一个线程等待另一个线程结束后才能执行，利用此原理我们可以设置一个监控线程用来等待程序线程执行完毕后输出返回结果，下面我们看下具体示例代码 首先定义一个结果实体类 public class Result { priva
线程 & 多线程
一朵花花
11-23 2496
线程 thread线程线程概念为啥要有线程?线程和进程的联系和区别线程管理多线程多线程程序缺点第一个多线程程序 线程 线程概念 所谓的"线程"，可以理解成轻量级"进程"，也是一种实现并发编程的方式 如果把一个进程，想象成是一个工厂，线程就是工厂中的若干个流水线 为啥要有线程? 可以实现并发编程 单核 CPU 的发展遇到了瓶颈，要想提高算力，就需要多核 CPU，而并发编程能更充分利用多核 CPU 资源 有些任务场景需要 “等待 IO”，为了让等待 IO 的时间能够去做一些其他的工作，也需要用到并发编程 线程
多线程一，什么是多线程，创建多线程的几种方式
热门推荐
世上哪有什么岁月静好,不过是有人替你负重前行
04-11 2万+
1 多线程相关概念 并发（Concurrent）：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。 同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。 并行（Parallel）：当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，这种方式我们称之为
08-04 多线程之Task
菜鸟爱飞不飞的博客
02-06 4033
目录前言一、Task开启线程的方式1、Task实例化2、Task.Run()静态方法3、TaskFactory二、Task由线程池管理三、父子线程 前言 Task诞生于.NETFramework 3.0，同时支持.NET Core Task被称为C# 中多线程的最佳实现 一、Task开启线程的方式 1、Task实例化 Task task = new Task(() => { Console.WriteLine($"==================new Task start {Th
Qt线程详解
lzw19971106的博客
04-28 3345
线程与进程有什么区别呢？ 举个简单的例子，当你在LOL的时候，在相同的桌面上可能有一个播放器正在播放你最喜欢的歌曲。这是一个两个进程并行工作的例子：一个进程运行LOL程序;另一个进程运行一个媒体播放器。这种情况最适合用多任务这个词来描述。进一步观察播放器，你会发现在这个进程内，又存在并行的工作。当播放器向音频驱动发送音乐数据的时候，用户界面上与之相关的歌词信息不断地进行更新。这就是单个进程内的并行...
C#单线程和多线程
百锦再的博客
01-08 1万+
单线程和多线程是计算机编程中的概念，用于描述程序的执行方式和资源利用方式。
线程的使用
weixin_48656058的博客
12-01 4380
线程 首先要了解进程和线程的区别: 进程是唯一的,一个进程可以开启多个线程。 比如:你的电脑开机了,你任务管理器里面运行的程序就是线程 1.线程的生命周期有五种状态: 创建、就绪、运行、阻塞、死亡 1.1 创建(创建方式往下找): 创建一个线程,线程进入创建状态。 1.2 就绪: start()方法用于使一个线程进入就绪状态。 1.3 运行: 执行run()方法使线程进入运行状态 1.4 阻塞: wait(等待)会让线程进入阻塞状态,会失去所占用的资源; 还有其他方式可以让一
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 561
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
java 异常包装
最新发布
fdvvg的博客
10-17 337
通过异常包装，可以在Java中有效地处理和传递异常。这样做不仅能保持原始异常的信息，还能为上层调用者提供更多的上下文信息。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 427
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
JavaWeb合集05-SpringBoot基础知识
qq_57340195的博客
10-17 854
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
代理模式、BigDecimal详解
Mr.W的博客
10-14 1075
BigDecimal可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过BigDecimal来做的。浮点数之间的等值判断，基本数据类型不能用 == 来比较，包装数据类型不能用 equals 来判断。想要解决浮点数运算精度丢失这个问题，可以直接使用BigDecimal来定义浮点数的值，然后再进行浮点数的运算操作即可​​// 0。
pyserini安装&使用
DreamLike_zzg的博客
10-14 618
代码。
Java线程优先级详解
"Java线程的优先级管理是多线程编程中的一个重要概念，它涉及到线程调度和执行的顺序。在Java中，线程的优先级被用来影响线程被操作系统选择执行的概率，但并不保证高优先级的线程一定会先于低优先级的线程执行。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值