java多线程1

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

文章目录

创建多线程

方式一

package com.pan;

class Window extends Thread{
    private static int ticket = 100;
    public void run(){
        while(true){
            if(ticket > 0){
                System.out.println(this.getName() + ":卖票，票号为：" + ticket);
                ticket--;
            }
            else{
                break;
            }
        }
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

方式二

class Window implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            if(i % 2 == 0){
            System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread thread = new Thread(w);
        thread.start();

        Thread t2 = new Thread(w);
        t2.start();
    }
}

Thread中的常用方法

  • start():启动当前线程（调用当前线程的run()）
  • run()
  • currentThread():静态方法，返回执行当前代码的线程
  • getName():获取当前线程的名字
  • setName():设置当前线程的名字，也可以通过构造方法的方式自定义线程的名字，例如：
class HelloThread extends Thread{
    @Override
    public void run(){

    }
    public HelloThread(String name){
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("T1");
        System.out.println(h1.getName());//T1
    }
}
  • yield():释放当前cpu的执行权
  • join():在线程A中调用b中的join(),此时A线程就进入阻塞状态，直到线程B执行结束之后，线程A才结束阻塞状态。
  • sleep(Long millitime):使当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态
  • isAlive():判断当前线程是否存活

线程的优先级

  • MAX_PRIORITY:10
  • MIN_PRIORITY:1
  • NORM_PRIORITY:5
    2.如何获取和设置当前线程的优先级
  • getPriority():获取线程的优先级
  • setPriority(int p):设置线程的优先级
    说明：高优先级的线程占有cpu执行权的概率高于低优先级的线程。

线程的生命周期

在这里插入图片描述

线程安全

例子：创建三个窗口卖票，总票数为100张。

  • 问题：买票过程中，出现了重票、错票–》出现了线程安全问题
  • 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
  • 解决方案：当一个线程A在操作ticket时，其他线程不能参与进来，直到线程A操作完成ticket时，其他线程才可以开始操作ticket，这种情况即使线程A出现了阻塞，也不能改变。
  • 在Java中，通过同步机制来解决线程安全问题。
  • 方式一：同步代码块
    synchronized(同步监视器){
    //需要被同步的代码
    }
    说明：1.操作共享数据(多个线程共同操作的变量)的代码，即为需要被同步的代码
    2.同步监视器俗称锁，任何一个类的对象都可以充当锁(多个线程必须共用一把锁)
    • 使用同步代码块解决实现Runnable接口创建多线程的方式的线程安全问题
      注意：可以考虑使用this充当同步监视器
class Window1 implements Runnable{
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while(true) {
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  • 使用同步代码块解决继承Thread类的方式的线程安全问题
    注意：慎用this充当同步监视器，可以考虑使用当前类充当同步监视器。
class Window extends Thread{
    private static int ticket = 100;
    static Object obj = new Object();
    public void run(){
        while(true) {
            synchronized (obj)/*synchronized (Window.class)*/ {
                //此时不能用this，因为this代表t1,t2,t3三个对象
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(this.getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowTest2 {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

以上两个的输出：

窗口1:卖票，票号为：100
窗口1:卖票，票号为：99
窗口1:卖票，票号为：98
窗口1:卖票，票号为：97
窗口1:卖票，票号为：96
窗口1:卖票，票号为：95
窗口1:卖票，票号为：94
窗口1:卖票，票号为：93
窗口1:卖票，票号为：92
窗口1:卖票，票号为：91
窗口1:卖票，票号为：90
窗口1:卖票，票号为：89
窗口1:卖票，票号为：88
窗口1:卖票，票号为：87
窗口3:卖票，票号为：86
窗口3:卖票，票号为：85
窗口3:卖票，票号为：84
窗口3:卖票，票号为：83
窗口3:卖票，票号为：82
窗口3:卖票，票号为：81
窗口3:卖票，票号为：80
窗口3:卖票，票号为：79
窗口3:卖票，票号为：78
窗口3:卖票，票号为：77
窗口3:卖票，票号为：76
窗口3:卖票，票号为：75
窗口3:卖票，票号为：74
窗口2:卖票，票号为：73
窗口2:卖票，票号为：72
窗口2:卖票，票号为：71
窗口2:卖票，票号为：70
窗口2:卖票，票号为：69
窗口2:卖票，票号为：68
窗口2:卖票，票号为：67
窗口2:卖票，票号为：66
窗口2:卖票，票号为：65
窗口2:卖票，票号为：64
窗口2:卖票，票号为：63
窗口2:卖票，票号为：62
窗口2:卖票，票号为：61
窗口2:卖票，票号为：60
窗口2:卖票，票号为：59
窗口2:卖票，票号为：58
窗口2:卖票，票号为：57
窗口2:卖票，票号为：56
窗口2:卖票，票号为：55
窗口2:卖票，票号为：54
窗口2:卖票，票号为：53
窗口2:卖票，票号为：52
窗口2:卖票，票号为：51
窗口2:卖票，票号为：50
窗口2:卖票，票号为：49
窗口2:卖票，票号为：48
窗口2:卖票，票号为：47
窗口2:卖票，票号为：46
窗口2:卖票，票号为：45
窗口2:卖票，票号为：44
窗口2:卖票，票号为：43
窗口2:卖票，票号为：42
窗口2:卖票，票号为：41
窗口2:卖票，票号为：40
窗口2:卖票，票号为：39
窗口2:卖票，票号为：38
窗口2:卖票，票号为：37
窗口2:卖票，票号为：36
窗口2:卖票，票号为：35
窗口2:卖票，票号为：34
窗口2:卖票，票号为：33
窗口2:卖票，票号为：32
窗口2:卖票，票号为：31
窗口2:卖票，票号为：30
窗口2:卖票，票号为：29
窗口2:卖票，票号为：28
窗口2:卖票，票号为：27
窗口2:卖票，票号为：26
窗口2:卖票，票号为：25
窗口2:卖票，票号为：24
窗口2:卖票，票号为：23
窗口2:卖票，票号为：22
窗口2:卖票，票号为：21
窗口2:卖票，票号为：20
窗口2:卖票，票号为：19
窗口2:卖票，票号为：18
窗口2:卖票，票号为：17
窗口2:卖票，票号为：16
窗口2:卖票，票号为：15
窗口2:卖票，票号为：14
窗口2:卖票，票号为：13
窗口2:卖票，票号为：12
窗口2:卖票，票号为：11
窗口2:卖票，票号为：10
窗口2:卖票，票号为：9
窗口2:卖票，票号为：8
窗口2:卖票，票号为：7
窗口2:卖票，票号为：6
窗口2:卖票，票号为：5
窗口2:卖票，票号为：4
窗口2:卖票，票号为：3
窗口2:卖票，票号为：2
窗口2:卖票，票号为：1

Process finished with exit code 0

同步的方式解决了线程的安全问题，局限性是操作同步代码时，只能有一个线程参与，其他线程等待，相当于一个单线程的过程，效率低。

  • 方式二：同步方法
    如果操作共享数据的代码完整的声明在一个方法中，我们可以将此方法声明为同步的。
  • 使用同步方法解决实现Runnable接口的方式的线程安全问题，如下：
class Window1 implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true) {
                show();
        }
    }
    public synchronized void  show(){//默认同步监视器为：this
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  • 使用同步方法处理继承Thread类的线程安全问题，如下：
class Window extends Thread{
    private static int ticket = 100;
    static Object obj = new Object();
    public void run(){
        while(true) {
            show();
        }
    }
    public static synchronized void show(){//同步监视器：Window.class
        /*public  synchronized void show(){*///同步监视器：t1,t2,t3，这种解决方式是错误的
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
        else{
            return;
        }
    }
}
public class WindowTest2 {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
  • 方式三：使用Lock锁方式
package com.hai;
import java.util.concurrent.locks.ReentrantLock;
/*
* 解决线程安全问题的方式之一：Lock锁
* */
class Window implements Runnable{
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try {
                //2.调用锁定方法lock()
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            } finally {
                //3.调用解锁方法：unlock
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
//synchronized与Lock的异同：
//相同：二者都可以解决线程安全问题
//不同：synchronized机制在执行完相应的同步代码以后，自动释放同步监视器，而Lock需要手动的启动同步（lock()),同时也需要手动结束同步(unlock())

关于同步方法：

  • 同步方法仍然涉及到同步监视器，只是不需要我们显示的声明。
  • 非静态的同步方法同步监视器是：this
  • 静态的同步方法，同步监视器是：当前类本身

使用同步机制将单例模式中的懒汉式改写为线程安全

package com.pan;
/*
* 使用同步机制将单例模式中的懒汉式改写为线程安全的
*
* */

class Bank{
    private Bank(){
    }
    private static Bank instance = null;
    //方式一：
//    public static synchronized Bank getInstance(){
//        if(instance == null){
//            instance = new Bank();
//            return instance;
//        }
//        return instance;
//    }
    //方式二：
    public static Bank getInstance() {
        if (instance == null) {
            synchronized (Bank.class){
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}
public class BankTest {
}

死锁

one：

public class TheadTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run(){
                synchronized (s1){
                    s1.append("a");
                    s1.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                synchronized (s2){
                    s1.append("b");
                    s2.append("2");
                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s1.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                synchronized (s1){
                    s1.append("d");
                    s2.append("4");
                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        });
    }
}

two：

class A{
    public synchronized void foo(B b){//A类的对象：a
        System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入A实例的foo方法");
        try{
            Thread.sleep(200);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("当前线程名：" + Thread.currentThread().getName() + "企图调用B实例的last方法");
        b.last();
    }
    public synchronized void last(){
        System.out.println("进入A类的last方法内部");
    }
}
class B{
    public synchronized void bar(A a){
        System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入了B实例的bar方法");
        try{
            Thread.sleep(200);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        a.last();
    }
    public synchronized void last(){
        System.out.println("进入B类的last方法内部");
    }
}
public class DeadLock implements Runnable {
    A a = new A();
    B b = new B();
    public void init(){
        Thread.currentThread().setName("主线程");
        a.foo(b);
        System.out.println("进入主线程之后");
    }
    public void run(){
        Thread.currentThread().setName("副线程");
        b.bar(a);
        System.out.println("进入副线程之后");
    }

    public static void main(String[] args) {
        DeadLock d1 = new DeadLock();
        new Thread(d1).start();
    }
}
pk5515
关注
专栏目录
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4281
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 24万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java多线程-CountDownLatch
weixin_45203607的博客
02-16 2630
介绍 CountDownLatch是一个同步辅助类，它允许一个或多个线程一直等待直到其他线程执行完毕才开始执行。 用给定的计数初始化CountDownLatch，其含义是要被等待执行完的线程个数。 每次调用CountDown()，计数减1 主程序执行到await()函数会阻塞等待线程的执行，直到计数为0 场景 1:多线程读取批量文件, 并且读取完成之后汇总处理 2:多线程读取Excel多个sheet,读取完成之后获取汇总获取的结果 3:多个人一起一起来吃饭,主人等待客人到来,客人一个个从不同地方来到饭店,主
【Java多线程】停止线程
一定要站在自己热爱的生活里闪闪发光
10-03 5万+
目录 1. 停止线程的方法 2. 判断线程是否是停止状态 3. 能停止的线程——异常法 4. 在沉睡中停止 5. 能停止的线程——暴力停止 6. 方法stop()与java,lang.ThreadDeath异常 7. 使用return停止线程 1. 停止线程的方法 在Java中有以下3种方法可以终止正在进行的线程： 1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2）使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend及resum
Java 多线程 —— 定时器
一纸春秋的博客
10-25 2132
定时器是一个线程工具，可以用于调度多个定时任务以后台线程的方式运行。 比如说，在开发中，我们需要做一些周期性的操作，比如每隔三分钟就清空一次文件夹，用定闹钟的方式人为的清空肯定是不合适的。这时就可以通过Timer和TimerTask类来实现，定时完成具体任务的功能。 这里需要注意的是，Timer和TimerTask都是线程，Timer是一个计时器，每个Timer对象都是单个后台线程，会依次执行每个任务。 Timer() 创建一个新的计时器： void schedule(TimerTask task, lo
Java多线程详解
坏蛋阿土的博客
11-06 6620
线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 6334
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
Java 多线程 测试
风信子
04-14 1956
Java 多线程 测试1 Callable2 Runnable3 Thread 1 Callable package com.xu.thread; import java.util.concurrent.Callable; /** * @author Administrator */ public class MyCallable implements Callable { @Override public Object call() throws Exception {
JAVA多线程实战
超级氯化钾的博客
07-21 2785
是计算机中的程序关于某数据集合的一次运行活动，，一个线程就是进程中一个单一顺序的控制流，进程是线程的容器，一个进程至少有一个线程，一个进程可以有多个线程OS中是以进程为单位分配资源，如虚拟存储控件、文件描述符。每个线程都有自己的线程栈JVM启动时会自动创建一个主线程，该主线程负责执行main方法。主线程就是运行main方法的线程。.........
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
详解java多线程的同步控制
01-20
同步控制是并发程序必不可少的重要手段，本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1465
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Java分布式锁
最新发布
juanmiao的专栏
10-12 657
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 870
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 675
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多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

pk5515

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值