Java之线程创建方式、状态问题

于 2019-11-06 22:39:48 发布
阅读量102 收藏
点赞数
分类专栏： Java 文章标签： Java 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45801172/article/details/102944851
版权

线程

想要学习线程就必须了解线程和进程之间的区别

线程和进程之间的区别

  1. 进程:对于操作系统而言,进程就是程序,多进程就是多个程序同时执行

    注意:一个进行可包含一到多个线程,每一个进程都有自己的代码和运行空间,进程之间切换开销较大,进程是资源分配的最小单位。

  2. 线程:程序中的顺序流,多线程就是一个程序中,多个顺序流在同时执行

    注意:一系列线程共享代码和数据空间,每个线程都有自己的程序计数器,线程之间切换开销较小,线程是cpu调度的最小单位

线程和进程的状态：新生->就绪->运行->阻塞->终止

线程的创建方式

1.继承Thread,重写run()方法
  1. 在run()方法中定义线程体
  2. 开启:使用start()方法开启线程
package thread01;
//创建线程的方法一:继承Thread类,并重写run()方法
public class ThreadDemo01 extends Thread{
	@Override
	public void run() {
		//定义线程体
		for(int i=1;i<=10;i++){
			System.out.println("一遍吃饭");
		}
	}
	
	public static void main(String[] args) {
		//1.创建线程体
		ThreadDemo01 th=new ThreadDemo01();
		//2.开启多线程
		th.start();
		//错误示例
//		th.run();  //请注意:直接调用run()方法,是方法的调用,并不是开启线程
		//3.执行同步执行主线程的方法
		for(int i=1;i<=10;i++){
			System.out.println("一遍玩手机");
		}
		//运行结果
		/*  一遍玩手机
			一遍玩手机
			一遍玩手机
			一遍玩手机
			一遍玩手机
			一遍玩手机
			一遍玩手机
			一遍玩手机
			一遍玩手机
			一遍玩手机
			一遍吃饭
			一遍吃饭
			一遍吃饭
			一遍吃饭
			一遍吃饭
			一遍吃饭
			一遍吃饭
			一遍吃饭
			一遍吃饭
			一遍吃饭
		 从运行结果可以看出，是先运行主方法里面的,在运行线程的
		 其实两个是同时运行的,但是由于cpu调度和效率的问题
		 所以会造成 先执行主方法在执行线程的假象
		 * 
		*/
	}
}

注意:继承Thread()中run()没有抛出异常,所以在它的子类也无法抛出异常。

2.实现Runnable接口,重写run()方法,推荐
  1. 实现Runnable接口,重写run()方法
  2. 通过Thread类中的start()开启线程,将实现Runnable的实例当成构建Thread对象的时候的参数
package thread01;
/*创建线程的方法二:
	实现Runnable接口,重写run()方法,推荐
	开启:通过Thread类中的start()开启线程
	优点:1.避免了单继承的局限性 2.实现了资源共享
*/
public class ThreadDemo02 implements Runnable{
	//重写方法,当被调用时候,会逐行执行里面的代码
	@Override
	public void run() {
		for(int i=1;i<=10;i++){
			System.out.println("一遍刷微博");
		}
	}
	public static void main(String[] args) {
		//1.创建线程体
		ThreadDemo02 th=new ThreadDemo02();
		//2.开启多线程  将实现Runable的实例当成创建Thread对象时候的参数
		Thread t=new Thread(th);//因为开启线程的方法在Thread中,Thread作为代理类出现
		t.start();
		//3.执行同步执行主线程的方法
		for(int i=1;i<=10;i++){
			System.out.println("一遍看头条");
		}

	}
	/*  运行结果如下
	 *  一遍看头条
		一遍刷微博
		一遍刷微博
		一遍刷微博
		一遍刷微博
		一遍刷微博
		一遍刷微博
		一遍刷微博
		一遍刷微博
		一遍刷微博
		一遍刷微博
		一遍看头条
		一遍看头条
		一遍看头条
		一遍看头条
		一遍看头条
		一遍看头条
		一遍看头条
		一遍看头条
		一遍看头条
	 */

}
案例一:模拟12306案例

需求:3个人去买100张火车票

要求:采用多线程的方法,

package thread01;
/*
 * 需求:3个人去买100张火车票
 * 要求:采用多线程的方法,
*/
//分析:100张票是3个共享的,所以可以放在类成员中,3个人购买说明有3个线程同时在操作
public class Web12306 implements Runnable{
	//设置火车票总数
	int tikets=100;
	//设置线程,我们知道每次只能购买一张,直到最后一张票卖完了才结束
	//行为:三个人购买100张票
	//在只有一个线程方法的前提下,每次购买一张,每个人调用一次,每人每次购买一张
	//线程体的方法为:每次购买一张的行为,直到100张结束
	@Override
	public void run() {
		//由于我们不知道什么时候买到100张,所以可以使用死循环
		while(true){
			
			System.out.println(Thread.currentThread().getName()+"购买倒数第"+tikets+"张");
			if(tikets<=0){break;}
			tikets--;
			
		}
	}
	
	public static void main(String[] args) {
		Web12306 web=new Web12306();
		//由于是三个人同抢100张票,所以是在同一个对象里面操作,不过这个对象有三个线程
		Thread th1=new Thread(web,"黄牛一");
		Thread th2=new Thread(web,"黄牛二");
		Thread th3=new Thread(web,"黄牛三");
		//开启三个人同时抢票的模式,就是 开启三个线程
		th1.start();
		th2.start();
		th3.start();
		/*运行结果如下:(部分)
				 *  黄牛一购买倒数第100张
					黄牛一购买倒数第99张
					黄牛一购买倒数第98张
					黄牛一购买倒数第97张
					黄牛一购买倒数第96张
					黄牛一购买倒数第95张
					黄牛一购买倒数第94张
					黄牛一购买倒数第93张
					黄牛一购买倒数第92张
					黄牛一购买倒数第91张
					黄牛一购买倒数第90张
					黄牛一购买倒数第89张
					黄牛一购买倒数第88张
					黄牛一购买倒数第87张
					黄牛一购买倒数第86张
					黄牛一购买倒数第85张
					黄牛三购买倒数第100张
					黄牛三购买倒数第83张
					黄牛三购买倒数第82张
					黄牛三购买倒数第81张
					黄牛三购买倒数第80张
					黄牛三购买倒数第79张
					黄牛二购买倒数第100张
			通过以上我们可以发现,虽然实现了每次每人抢一次票的功能,
			但是有的人抢到同样票,这个是因为线程不安全
		*/
		
	}

}
案例二:龟兔赛跑

需求:兔子、乌龟同时在跑,当某一个人跑到100步时,比赛结束,兔子每跑10步休息5ms

package thread01;
/*
 * 龟兔赛跑: 兔子,乌龟同时在跑,有人跑到100步游戏结束,兔子跑十步休息5ms
 * 
 * 分析:龟兔同时在赛跑,都是在赛跑,说明是执行同样的方法
 * 		当跑满100步时,说明已经比赛结束,那么说明需要有标识,提示说明时候结束比赛
 * 判断条件:某个跑满100步		
 */
public class Race04 implements Runnable{
	//3.设置一个标识
	boolean flag=false;

	//1.龟兔赛跑,每次执行的动作
	//2.在这个方法体中,需要一个判断
	//	2.1某个跑满100步,给一个标识
	//	2.2告诉下一个,上面已经赢了,停止跑步
	@Override
	public void run() {
		int i=1;
		//判断条件一,当跑满100步,存储获胜者的名字
		while(i<=100){
			//如果是乌龟直接跑,但如果是兔子则应跑10步休息5ms
			if("兔子".equals(Thread.currentThread().getName())&&(i%10==0)){
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");	
			i++;
			//当跑到100步的时,设置变量flag变为true,其中flag为共享的资源
			if(i==100){
				flag=true;
				System.out.println(Thread.currentThread().getName()+"获胜了");
				break;
			}
			if(flag){
				break;
			}
			
		
		}
	}
	//主方法
	public static void main(String[] args) throws InterruptedException {
		//1.创建对象
		Race04 race=new Race04();
		//2.开启线程 
		//2.1创建Thread对象
		Thread tortise=new Thread(race,"乌龟");
		Thread rabbit=new Thread(race,"兔子");
		//2.2开启线程
		tortise.start();
		rabbit.start();
	
	}
}
3.实现Callable接口,重写call方法
  1. 实现Collable接口,重写call()方法,方法中定义线程体
  2. 开启
    1. 创建本身对象:就是构建自己的实例
    2. 创建执行任务:构建一个线程池
    3. 提交执行:
    4. 获取结果
package thread01;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
 * 龟兔赛跑: 兔子,乌龟同时在跑,有人跑到100步游戏结束,兔子跑十步休息5ms
 * 
 * 分析:龟兔同时在赛跑,都是在赛跑,说明是执行同样的方法
 * 		当跑满100步时,说明已经比赛结束,那么说明需要有标识,提示说明时候结束比赛
 * 判断条件:某个跑满100步		
 */
public class Race05 implements Callable{
	//3.设置一个标识
	boolean flag=false;


	//主方法
	public static void main(String[] args) throws InterruptedException, ExecutionException  {
		//01.创建对象
		Race05 race=new Race05();
		//02.创建执行任务 设置两个线程
		ExecutorService server=Executors.newFixedThreadPool(2);
		//03.提交执行
		Future result01=server.submit(race);//传入的参数是 对象race
		Future result02=server.submit(race);
		//04.获取结果
		String s1=(String) result01.get();
		String s2=(String) result01.get();
		//05.打印
		System.out.println(s1+"-->"+s2);
	
	}
	//1.龟兔赛跑,每次执行的动作
	//2.在这个方法体中,需要一个判断
	//	2.1某个跑满100步,给一个标识
	//	2.2告诉下一个,上面已经赢了,停止跑步
	@Override
	public Object call() throws Exception {

		int i=1;
		//判断条件一,当跑满100步,存储获胜者的名字
		while(i<=100){
			//如果是乌龟直接跑,但如果是兔子则应跑10步休息5ms
			if("兔子".equals(Thread.currentThread().getName())&&(i%10==0)){
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");	
			i++;
			//当跑到100步的时,设置变量flag变为true,其中flag为共享的资源
			if(i==100){
				flag=true;
				System.out.println(Thread.currentThread().getName()+"获胜了");
				break;
			}
			if(flag){
				break;
			}

		}
		return Thread.currentThread().getName();
	}
}
其他的类也同样能够使用线程 如:成员内部类 局部内部类以及匿名内部类

代码如下:

package thread02;

public class Demo01 {
	//成员内部类
	static class Inner01 implements Runnable{

		@Override
		public void run() {
			for(int i=0;i<10;i++){
				//线程休眠10毫秒
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("成员成员内部类"+i);
			}
		}
		
	}
	
		
	public static void main(String[] args) {
		//方法内部类
		class Inner02 implements Runnable{
			@Override
			public void run() {			
				for(int i=0;i<10;i++){
				try {
					//线程休眠10毫秒
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("局部成员内部类"+i);
			}}
			
		}
		//创建对象
		Inner01 inner01=new Inner01();
		Inner02 inner02=new Inner02();
		//创建Thread对象
		Thread inner001=new Thread(inner01);
		Thread inner002=new Thread(inner02);
		//开启线程
		inner001.start();
		inner002.start();
		//匿名内部类  
		new Thread(new Runnable(){
			//匿名内部内的方法
			@Override
			public void run() {			
				for(int i=0;i<10;i++){
				try {
					//线程休眠10毫秒
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("匿名内部类"+i);
			}}
			
		}){}.start();
		//正常的方法
			for(int i=0;i<10;i++){
			try {
				//线程休眠10毫秒
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("正常方法"+i);
		}
	}
}

线程的状态问题

状态解释
NEW启动
RUNNABLE可运行线程的线程状态。
BLCOKED受阻塞并且正在等待监视器锁的某一线程的线程状态。
WAITING某一等待线程的线程状态。
TIMED_WAITING具有指定等待时间的某一等待线程的线程状态。
TERMINATED已终止线程的线程状态。
线程的状态过程
  1. 新生状态:new
  2. 就绪状态:start(),线程就会进入到就绪队列,等待cpu的调度
  3. 运行状态:
  4. 阻塞状态:非正常执行完毕,通过程序控制
  5. 终止状态:

注意:一个线程一旦进入到终止状态,没有办法恢复了,就算是重写一个new 线程,也不是刚才那个线程了。

一个线程一旦进入到阻塞状态,无法直接恢复到运行,等待阻塞解除之后,恢复到就绪状态。

为什么不是到运行状态呢?这个是因为要等待cpu的调度。

如何进入到就绪状态
  1. 正常的开始 start()
  2. 阻塞状态解除
  3. 线程切换,被切换的线程就进入到就绪状态
  4. yield()礼让线程
如何进入到阻塞状态
  1. sleep()方法 线程休眠
    1. 可以模拟网络延迟
    2. 放大问题的可能性
    3. 也叫做抱着资源睡觉,同步的对象资源,让出cpu资源
  2. join()方法
  3. wait()方法
如何让线程进入到终止状态
  1. 正常执行完毕
  2. destorty()|stop() 已过时
  3. 通过标识手动判断-建议
案例一:模拟网络延迟 (进入到阻塞状态 sleep())
package thread02;

public class StateDemo02 implements Runnable{
	public static void main(String[] args) {
		new Thread(new StateDemo02()).start();;
	}
	//模拟倒计时

	@Override
	public void run() {
		for(int i=10;i>=0;i--){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("倒计时:"+i);
		}
	}
}
案例二:进入到就绪状态 yield
package thread02;

public class YieldDemo03 implements Runnable {

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"start");
		//每次执行到该行时候,让出资源
        Thread.yield();//静态方法   礼让线程
		System.out.println(Thread.currentThread().getName()+"end");
	}
	
	public static void main(String[] args) {
		new Thread(new YieldDemo03(),"我是A的").start();
		new Thread(new YieldDemo03(),"我是B的").start();
	}

}
案例三:合并线程
package thread02;
/*
*/
public class JoinDemo05 {
	public static void main(String[] args) {
		new Thread(new Father()).start();
	}
}


//自定义类    Father
class Father implements Runnable{

	@Override
	public void run() {
		System.out.println("1.Father want somking");
		System.out.println("2.give money to son");
		Thread th=new Thread(new Son());
		//父亲先开始
		th.start();
		//加入儿子
		try {
			th.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("8.somking");
	}
}

线程安全

多个线程同时操作同一个资源的时候,才有可能出现线程安全问题

通过同步synchronized关键字控制线程安全

同步方法:静态方法和成员方法

同步块:synchronized(列|this|资源|代码)

this,锁住当前对象

类名:类名.class 一个类的class对象,一个类只有一个Class对象

几个方法的优缺点
  1. 锁方法简单,但是效率低,因为锁的代码范围太大的整个方法,如果想要提高效率,可以同步块
  2. 同步类,相当于把这个类的所有对象全部同步了,如果想要只同步当前对象就可以实现,可以同步this
  3. 同步this,同步当前对象,锁住这个对象,这个对象的所有资源都被锁住了,如果只想要锁住其中某个资源,可以只锁这个资源
  4. 同步资源,一般指成员变量
    • 锁:要锁不变的东西,自定义引用数据类型的对象地址永远不变

注意

锁,要锁住不变的东西,会变的锁不住

同步的范围太大,效率低,同步的范围太小,锁不住

案例一:锁住当前对象this
package practice05;

public class JDS{

	public static void main(String[] args) {
		//1.创建对象
		SyncThread syncThread = new SyncThread();
		//2.创建线程 sycThread是对象
		Thread thread1 = new Thread(syncThread, "SyncThread1");
		Thread thread2 = new Thread(syncThread, "SyncThread2");
		//3.开启线程
		thread1.start();
		thread2.start();
	}

}
/**
 * 同步线程
 */
class SyncThread implements Runnable {
   private static int count;

   public SyncThread() {
      count = 0;
   }

   public  void run() {
	   //this,锁住当前对象
      synchronized(this) 
	   {
         for (int i = 0; i < 5; i++) {
            try {
               System.out.println(Thread.currentThread().getName() + ":" + (count++));
               Thread.sleep(100);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }
   }

   public int getCount() {
      return count;
   }
}

​ 当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。

weixin_45801172
关注
专栏目录
Java多线程-JDK5.0新增线程创建方式
02-03
### Java多线程-JDK5.0新增线程创建方式 #### 一、新增方式1：实现Callable接口 ##### （1）介绍 自Java 5.0起，为提高线程管理的灵活性与效率，引入了`Callable`接口，这是一种全新的创建线程的方式。与传统的`...
死磕Java系列之多线程创建和线程状态
尚拙的博客
01-12 259
当我们提到单线程的时候，会思考几个问题： （1）线程是什么？人们通常将线程和进程进行比较，那么，线程和进程有哪些相似和不同呢？ （2）如何创建一个线程呢？创建线程有哪些方法呢？ （3）当我们定义好一个线程以后，那么，线程有哪些状态呢？ 这篇文章将会从这三个方面介绍线程的基础知识。 （一）线程是什么？         在计算机程序中，一个程序能够执行多个任务，通常将每一个任务称之为线程，可以运行...
Java线程状态转换关系实例解析
08-18
Java线程状态转换关系实例解析 Java线程状态转换关系实例解析是Java多线程编程中的一种重要概念，它指的是Java线程在不同的状态之间的转换关系。了解这些状态转换关系可以帮助开发者更好地编写多线程程序，避免线程...
总结Java中线程的状态及多线程的实现方式
09-02
Java提供了两种主要的方式来创建和管理线程：直接继承`Thread`类和实现`Runnable`接口。线程的状态则描述了线程在执行过程中的不同阶段。 线程的状态主要包括： 1. **新建状态（New）**：当使用`new Thread()`创建...
Java多线程 线程状态原理详解
08-25
Java多线程是并发编程中的核心概念...理解线程状态以及它们之间的转换对于调试多线程问题、优化并发性能以及避免死锁和竞态条件等并发问题至关重要。熟练掌握这些知识能帮助开发者编写出更加健壮和高效的Java并发程序。
Java线程状态流转图
05-03
Java线程状态流转图是一种用于描述Java线程生命周期中不同的状态和状态转换的图形表示方式。该图形展示了Java线程从创建到终止的整个生命周期，并详细介绍了每种状态的特点和转换规则。 NEW（初始化状态） 在Java...
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功
10-10
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功功率可达10kW或10kVar，甚至更高
SpringBoot+Vue工厂生产设备维护管理系统答辩PPT.ppt
10-10
计算机毕业设计答辩PPT
CPA 税法 马兆瑞 基础班 第10章-本章概述-PPT-8页.pdf
10-10
CPA 税法 马兆瑞 基础班 第10章-本章概述-PPT-8页.pdf
CCS软件之工程模板的创建
10-10
工程模板创建的基础文件
nmpc非线性模型预测控制从原理到代码实践 含4个案例 自动泊车轨迹优化； 倒立摆上翻控制； 车辆运动学轨迹跟踪； 四旋翼无人机
10-10
nmpc非线性模型预测控制从原理到代码实践 含4个案例 自动泊车轨迹优化； 倒立摆上翻控制； 车辆运动学轨迹跟踪； 四旋翼无人机轨迹跟踪。
SpringBoot+Vue多媒体素材管理系统答辩PPT.pptx
10-10
计算机毕业设计答辩PPT
cmake-3.30.1-windows-arm64.msi win11 on arm 通过cmake编译&运行C++代码
10-10
cmake-3.30.1-windows-arm64.msi 安装完毕后一定要设置环境变量。 可以参考：https://blog.csdn.net/feng8403000/article/details/142767555
基于BOSS直聘数据分析师职位信息的爬虫实现、数据分析、数据可视化和机器学习预测的综合性项目python源码.zip
最新发布
10-10
基于BOSS直聘数据分析师职位信息的爬虫实现、数据分析、数据可视化和机器学习预测的综合性项目python源码.zip
图像处理之直方图均衡化与CLAHE技术详解及Python代码实现（包含详细的完整的程序和数据）
10-10
内容概要：本文详细介绍并提供了如何使用 OpenCV-Python 在不同颜色空间下进行直方图均衡化（Histogram Equalization）以及自适应直方图均衡化（Adaptive Histogram Equalization, AHAE 或称为 Contrast Limited Adaptive Histogram Equalization, CLAHE）的实际应用示例，从原理出发，对比这两种方法的效果及其特点。 适合人群：有一定 Python 编程能力并对 OpenCV 具有基本认知的开发者和研究人员。 使用场景及目标：可用于改善数字影像质量的应用场合，在医疗、安防监测、遥感分析等多种视觉任务中有广泛的用途。 其他说明：本文除了介绍两种主要的直方图均衡化技术外，还讨论了如何针对彩色图像在 HSV 和 YUV 等色彩模型中进行优化操作，并给出完整的源代码，便于读者上手试验。此外，提示使用者注意在特定环境下使用时可能出现的弊端以及未来的研究方向。
CPA 《税法》 马兆瑞 教材精讲 第十一章印花税法和企业所得税法 第一段.pdf
10-10
CPA 《税法》 马兆瑞 教材精讲 第十一章印花税法和企业所得税法 第一段.pdf
Python实现循环链表数据结构（包含详细的完整的程序和数据）
10-10
本文详细介绍了循环链表这一数据结构的两种形式—循环单链表与循环双链表的具体实现方法，并给出了具体的操作实例。内容涉及节点的添加与删除，查找元素等功能以及如何计算列表的长度。 适合人群：具有Python基础知识并对数据结构有一定兴趣的学习者与程序员。 使用场景及目标：适用于约瑟夫问题，循环队列等问题，通过学习能够更好地理解和运用这类结构来优化程序。 其他说明：强调正确的指针管理与合理的错误检查对于防止运行时发生故障（如内存泄漏和断开链表）是非常重要的，并提出可能进一步提升性能的方向。
Django+Vue公务员考试信息管理系统答辩PPT.ppt
10-10
计算机毕业设计答辩PPT
python 程序 截图工具
10-10
python 程序 截图工具
Java多线程：详解线程状态与创建方式
1. 初始状态（被创建）：当一个线程对象被创建，但尚未调用`start()`方法时，它处于被创建状态。这个阶段是线程的起点，表示线程尚未开始执行。 2. 运行状态：当调用`start()`方法后，线程进入运行状态，此时CPU...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值