java基础----线程

最新推荐文章于 2024-07-14 13:21:09 发布
最新推荐文章于 2024-07-14 13:21:09 发布
阅读量331 收藏
点赞数
分类专栏： Java学习 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zhuchang1999/article/details/122169865
版权

目录

1、线程简介
2、线程实现（重点）
3、线程状态
4、线程同步（重点）
5、线程通信问题
6、高级主题
现实中同时做多件事情，看起来是多个任务在做，本质上我们大脑同一时间依旧只做了一件事情

普通方法和多线程
在这里插入图片描述

程序、进程、线程

操作系统中运行的程序就是进程，比如QQ、游戏、IDE等
一个进程可以有多个线程，如视频中同时听到声音，看图像，看弹幕等

  • 程序：是指指令和数据的有序集合，其本身没有任何运行含义，是一个静态的概念
  • 进程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配单位
  • 在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位

注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，cpu只能执行一个代码，
因为切换的很快，所以就有同时执行的错觉。

  • 线程就是独立的执行路径
  • 在程序中，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程
  • main（）称为主线程，为系统的入口，用于执行整个线程
  • 在一个进程中，如果开辟多个线程，线程的运行由调度器（CPU）安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
  • 对同一份资源操作时，会存在资源抢夺的问题，需加入并发控制（例如10000抢100张票，加入并发，让人排队购票）
  • 线程会带来额外的开销，如cpu调度时间，并发控制开销
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

三种创建方式：
1、Thread class ----->继承Thread类（重点）
2、Runnable 接口 ------>实现Runnable接口（重点）
3、Callable接口-------->实现Callable接口

1、Thread

  • 自定义线程继承Thread类
  • 重写Run(）方法，编写线程执行体
  • 创建线程对象，调用start()方法启动线程

//创建线程方式一:继承Thread类，重写run()方法，调用start开启线程，在这里main方法线程和run方法线程是同时进行的
//总结：注意，线程开启不一定立即执行，由CPU调度执行

public class ThreadDemo1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("这是run方法线程"+i);
        }
    }
    public static void main(String[] args) {
        //创建一个线程对象
        ThreadDemo1 thread1 = new ThreadDemo1();
        //调用start方法开启线程
        thread1.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("这是主线程"+i);
        }
    }
}

2、实现Runnable接口
创建一个线程声明Runnable接口，那个类实现run方法，然后可以分配类的实例，在创建Thread时作为参数传递，并启动。

  1. 定义MyRunnable类实现Runnable接口
  2. 实现run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程
    避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
//创建线程方式：实现runnable,重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread implements Runnable{

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 100; i++) {
            System.out.println("这是run方法线程"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口实现类对象
        TestThread testThread = new TestThread();
//        Thread T = new Thread(testThread);
//        T.start();

        //创建线程对象，通过线程对象开启线程代理
        new Thread(testThread).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("这是main方法线程"+i);
        }
    }

}

案例：线程龟兔赛跑

public void Race implemennts Runnable(){
private static String winner;
@Override
public void run(){
	
	for(int i=0; i<=100;i++){
	 //给兔子增加睡眠
     if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
       try {
            Thread.sleep(10);
       }catch (InterruptedException e){
            e.printStackTrace();
            }
       }
	 //判断比赛是否结束
	 boolean flag = gameover(i);
	 if(falg==flase){
		break;
	}
	 System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
	}
}
public boolean gameover(int steps){
	if(winner!=null){
		return true;
	}
	{
		if(steps == 100){
			winner = Thread.currentThread().getName();
			System.out.println("winner is"+winner);
			return true;
		}
	}
	return false;
}
public staic void main(){
	Race race = new Race;
	new Thread(race,"兔子").start;
	new Thread(race,"乌龟").start;
}
}

3、实现Callable接口（基础篇了解即可）
1、实现callable接口，需要返回值类型
2、重写call方法，需要抛出异常
3、创建目标对象
4、创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5、提交执行：Futureresult1 = ser.submit(t1);
6、获取结果：boolean r1 = result1.get()
7、关闭服务：ser.shutdownNow();

静态代理

Lambda表达式

  • 理解Functional interfac（函数式接口）
  • 函数式接口的定义：
    任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
    对于函数式接口，我们可以通过lambda表达式来创建 该接口对象
    在这里插入图片描述
/*
* 推导lambda表达式
* */
public class TestLambda1 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda(){
            System.out.println("lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        like = new Like2();
        like.lambda();
        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda(){
                System.out.println("lambda3");
            }
        }
        like = new Like3();
        like.lambda();
        //5.匿名局部类，没有类的名称，必须借助接口或者父类
        like = new ILike(){
            @Override
            public void lambda(){
                System.out.println("lambda4");
            }
        };
        like.lambda();
        //6.用lambda简化
        like = () -> {
            System.out.println("lambda5");
        };
        like.lambda();
    }
}

//1.定义一个函数接口
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda(){
        System.out.println("lambda");
    }
}


public class Testlambda2 {
    //静态内部类
    static class Love implements ILove{
        @Override
        public void love(int a){
            System.out.println("lambda"+a);
        }
    }
    public static void main(String[] args) {
        ILove love = new Love();
        love.love(2);
        love = new Love();
        love.love(3);
        //局部内部类
        class Love implements ILove{
            @Override
            public void love(int a){
                System.out.println("lambda"+a);
            }
        }
        love = new Love();
        love.love(4);
        //匿名内部类
        love = new ILove(){
          @Override
          public void love(int a){
              System.out.println("lambda"+a);
          }
        };
        love.love(5);
        //lambda简化
        love = (int a) -> {
            System.out.println("lambda"+a);
        };
        love.love(6);
        //lambda简化1.参数类型省略
        love = (a) ->{
            System.out.println("lambda"+a);
        };
        love.love(7);
        //lambda简化2.简化括号
        love = a -> {
            System.out.println("lambda"+a);
        };
        love.love(8);
        //lambda简化3.简化花括号
        love = a -> System.out.println("lambda"+a);
        love.love(9);

        //总结：
            //lambda表达式只能有一行代码的情况下，才能简化花括号
            //前提为接口为函数式接口
            //当参数有两个的时候不能去掉小括号
            //多个参数也可以去掉参数类型，要去掉都去掉
    }
}
interface ILove{
    void love(int a);
}

class Love implements ILove{
    @Override
    public void love(int a){
        System.out.println("lambda"+a);
    }
}

线程五大状态

  1. 创建状态
  2. 就绪状态
  3. 阻塞状态
  4. 运行状态
  5. 死亡状态

    setPriority(int newPriority) :更改线程的优先级
    static void sleep(long mills) :在指定的毫秒数内让当前正在执行的线程休眠
    void join() 等待该线程终止
    static void yield() 暂停当前正在执行的线程对象，并执行其他线程
    void interrupt() 中断线程，别用这个方式
    boolean isAlive() 测试线程是否处于活动状态

线程停止

//测试stop
//1.建议线程正常停止-----》利用次数，不建议死循环
//2.建议使用标志位----》设置一个标志位
//3.不要使用stop或者destory等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
    //1.设置一个标识位
    private boolean flag = true;

    @Override
    public void run(){
        int i = 0 ;
        while (flag){
            System.out.println("Run"+i++);
        }
    }
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0;i<1000;i++){
            System.out.println("main"+i);
            if(i==909){
                testStop.stop();
                System.out.println("线程结束");
            }
        }
    }
}

线程休眠sleep

  • sleep（时间）指定当前线程阻塞的毫秒数
  • sleep存在异常InterruptedException
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延时，倒计时等
  • 每一个对象都有一个锁，sleep不会释放锁
//模拟网咯延迟：放大问题的发生性

public class TestSleep implements Runnable{

    //票数
    private int ticketNums = 10;
    @Override
    public void run(){
        while(true){
            if(ticketNums<=0){
                break;
            }
            //模拟延时
            try{
                Thread.sleep(100);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"第几张"+ticketNums--);
        }
    }

    public static void main(String[] args) {
        TestSleep ticket = new TestSleep();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小白").start();
        new Thread(ticket,"小红").start();
    }
}


import java.text.SimpleDateFormat;
import java.util.Date;

//模拟倒计时
public class Testsleep2 {

    public static void main(String[] args) {
/*    非静态方法需要new一个对象
        Testsleep2 testsleep2 = new Testsleep2();
        try {
            testsleep2.tenDown();
        }catch (InterruptedException e){
            e.printStackTrace();
        }*/
    try {
        //静态方法可以直接调用
        tenDown();
    }catch (InterruptedException e){
        e.printStackTrace();
    }
    //打印当前系统时间
        Date startTime = new Date(System.currentTimeMillis());
        while (true){
            try{
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
/*    public void tenDown() throws InterruptedException{
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
                break;
            }
        }
    }*/
    //模拟倒计时
    public static void tenDown() throws InterruptedException{
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
                break;
            }
        }
    }
}

线程礼让

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让CPU重新调度，礼让不一定成功，看CPU心情
//测试礼让线程
//礼让不一定成功，看CPU心情
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"A").start();
        new Thread(myYield,"B").start();
    }
}

class MyYield implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程执行结束");
    }
}

join

  • join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
  • 可以想象成插队
//测试插队
public class TestJoin implements Runnable{

    @Override
    public void run(){
        for (int i=0;i<1000;i++){
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i=0;i<1000;i++){
            if(i==200){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }

}

线程状态观测

  • Thread.State
  • 线程状态，线程可以处于以下状态之一
    NEW：尚未启动的线程处于此状态
    RUNNABLE:在java虚拟机中执行的线程处于此状态
    BLOCKED：被阻塞等待监视器锁定的线程处于此状态
    WAITING:正在等待另一个线程执行特定动作的线程处于此状态
    TIMED_WAITING：正在等待另一个线程 执行动作达到指定等待时间的线程处于此状态
    TERMINATED:已退出的线程处于此状态
//观察测试线程的状态
public class TestState {
    public static void main(String[] args) throws InterruptedException{
        Thread thread = new Thread(()->{
           for(int i=0;i<5;i++){
               try {
                   Thread.sleep(1000);
               }catch (InterruptedException e){
                   e.printStackTrace();
               }
               System.out.println("///");
           }
        });

        //观察状态
        Thread.State state =thread.getState();
        System.out.println(state);

        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state); //RUN

        while (state != Thread.State.TERMINATED) {//只要线程不终止，就一直输出状态
            Thread.sleep(1000);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态

        }
        //thread.start();//死亡之后的线程不能再次启动
    }
}

线程优先级

线程优先级高不一定先运行，主要是看CPU调度
JAVA提供一个线程 调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
线程的优先级用数字表示，范围从1-10
使用以下方式改变或获取优先级
getPriority()
setPriority()—优先级的设定建议咋start()调度前

//测试线程的优先级
public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级为5
        System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //先设置优先级
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(10);
        t4.start();

        t5.setPriority(7);
        t5.start();

        t6.setPriority(8);
        t6.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
    }
}

守护(daemon)线程

有一个方法setDaemon()–true:守护线程，否则不守护线程

有一个线程与用户线程一直一起，直到虚拟机将用户线程执行结束

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 如:后台记录操作，垃圾回收机制
//测试守护线程
//上帝守护你
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You1 you = new You1();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示用户线程,正常的线程都为用户线程
        thread.start(); //上帝守护线程启动

        new Thread(you).start(); //
    }
}

//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("一直");
        }
    }
}
//你
class You1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3650; i++) {
            System.out.println("开心");
        }
        System.out.println("=========不开心-----------------------------------------------");
    }
}

同步方法synchronized

同步：队列+锁

死锁

多个线程互相抱着对方需要的资源，然后形成僵持
产生死锁的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
    上面列出死锁的四个必要条件，我们只要想办法破坏其中任意一个或多个条件就可以避免死锁发生

线性池

背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
好处：

  1. 提高响应速度
  2. 降低资源消耗
  3. 便于线程管理
小朱Code
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《Java并发编程实战》【第四部分 高级主题】
lyw4631的博客
03-09 375
文章目录第13章 显示锁第14章 构建自定义的同步工具第15章 原子变量与非阻塞同步机制第16章 Java内存模型 第13章 显示锁 第14章 构建自定义的同步工具 第15章 原子变量与非阻塞同步机制 第16章 Java内存模型 ...
Java基础[06-多线程].ppt
12-09
Java中的多线程是编程中一个重要的概念，尤其在大数据处理和并发操作中不可或缺。Java提供了两种主要的方式来创建和管理线程：继承`Thread`类和实现`Runnable`接口。 **1. 继承Thread类实现多线程** 当你创建一个...
java高级主题
weixin_34408717的博客
05-24 125
1java.util.concurrent.locks.LockSupport park：阻塞线程。 unpark：解除阻塞线程。 线程阻塞最基础的组件。 2sun.misc.Unsafe 可以用来在任意内存位置读写数据。 转载于:https://www.cnblogs.com/hustdc/p/10917434.html...
Java学习之java高级特性
热门推荐
ling的博客
04-13 1万+
本部分内容主要有集合框架及泛型，实用类，输入和输出处理，注解与多线程，网络编程与XML技术。初次学习这部分会感觉很难，主要是概念难于理解，最好是多看看例子，多练习。下面是个人的总结 一、集合框架及泛型1、集合框架是一套性能优良、使用方便的接口和类（位于java.util包中）解决数组在存储上不能很好适应元素数量动态变化，查找效率低的缺陷集合接口： Map、Collection(子接口List、Se...
Java多线程高级主题
weixin_30628077的博客
04-09 121
任务定时调度 通过Timer和TimerTask，我们可以实现定时启动某个线程。 java.util.Timer：类似闹钟的功能，本身实现的就是一个线程 java.util.TimerTask：一个抽象类，该类实现了Runnable接口，所以该类具备了多线程的能力 /** * 任务调度：借助Timer 和 TimerTask 实现 */ public class TimerTask { ...
java基础-java环境
weixin_47384874的博客
11-09 5761
一、java环境的搭建 Java虚拟机-JVM jvm（java virtual machine）:java虚拟机，简称jvm，是运行所有Java程序的假象计算机，是java程序的运行环境，是java最具吸引力的特征之一，编写的java代码，都运行在jvm之上， 跨平台：任何软件的运行，都必须运行在操作系统之上，我们用java编写的软件可以运行在任何操作系统上，这个特性称之为java语言的跨平台特性，该特性是由jvm实现的，我们编写的程序运行在jvm上，而jvm运行在操作系统上。 二、Java语言运
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
java课件-5-多线程
01-10
总之，Java多线程编程是一个深度和广度都非常大的主题，涵盖了从基础的线程创建到复杂的并发控制策略，理解并熟练掌握这些知识对于编写高效、可靠的并发Java应用程序具有决定性的影响。通过学习提供的课件和实战练习...
java 高级理论-4
10-04
本学习资料主要针对已经掌握了Java基础知识的学员，旨在深入理解Java的核心概念和技术，包括面向对象的深入解析、多线程、集合框架、异常处理、IO流、反射、注解等主题。 1. **面向对象的深入解析**： - 抽象：...
Java多线程基础-优秀程序员
04-10
线程开发05_线程命名06_线程休眠07_线程优先级08_线程礼貌09_关键资源问题关键../等待...源码详情01_串行与并发02_进程与线程"03线程的生命04.线程的开辟05_线程的命名06_线程的休眠07_线程的优先08_线程的礼让09_...
Java高级主题（1）——（概述）
houjingjun的专栏
03-09 914
java在经过基础的语法学习之后，如果要更深入的学习，最好是对java的一些主题进行分类学习，下面就是java涉及的一些高级主题，如果要详细描述的话，每个主题都可能需要一本几百业的书，我这里作些简化，希望能够给初学者提升java技能带来一点点帮助。（部分图和代码摘自网络） 1、java基础 A、Java的IO框架，这个既是基础，也是实际应用中首先应该掌握的一个主题，必须要熟练。可能是因为太基础
jAVA高级面试点
蚂蚁博客
06-23 5639
1、常用设计模式 单例模式：懒汉式、饿汉式、双重校验锁、静态加载，内部类加载、枚举类加载。保证一个类仅有一个实例，并提供一个访问它的全局访问点。 代理模式：动态代理和静态代理，什么时候使用动态代理。 适配器模式：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 装饰者模式：动态给类加功能。
分享 5 个实用的 Java 开源论坛系统！
HollisChuang's Blog
09-30 4486
推荐 5 个论坛类开源项目，除了有 1 个是基于 PHP 开发之外，其他都是基于 Java ,并且大部分都是基于 Spring Boot 这个主流框架来做的。欢迎小伙伴们在评论区补充啊！...
JAVA 桌面程序的外观风格+主题场景 (更新)
llltaotao的博客
09-16 2658
import javax.swing.UIManager;int i = 0;try { //UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");//JAVA默认的跨平台外观风格UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAnd
配置Java开发环境
Broken_x的博客
07-10 1547
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 519
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
【Go系列】 Sync并发控制
最新发布
u013379032的博客
07-14 631
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 279
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值