分布式原理

最新推荐文章于 2023-06-29 09:46:58 发布
最新推荐文章于 2023-06-29 09:46:58 发布
阅读量1.1k 收藏
点赞数
分类专栏： 分布式 文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42061233/article/details/111181209
版权

一.并发编程

  1. 卖票问题
    类似于12306卖火车票的问题。假设有10个售票员，共售150张票。
    1.1. 首先尝试单进程顺序执行

    public class TicketSeller1{
	
	public void SellTicket(int agent,int numTicketToSell){
		while(numTicketToSell>0){
			System.out.println("agent:"+agent+"sells a ticket");
			numTicketToSell--;
		}
	}

	public static void main(String[] args) {
		TicketSeller1 s=new TicketSeller1();
		int numAgent=10;
		int numTicket=150;
		for(int agent=1;agent<=numAgent;agent++){
			s.SellTicket(agent,numTicket/numAgent);
		}
	}
}

    结果：10个售票员，每人售票15张。

    1.2. 给每个售货员加上线程，进行多线程并发执行

    public class TicketSeller2 implements Runnable{
	
	public int agent;
	public int numTicketToSell;
	
	@Override
	public void run(){
		while(numTicketToSell>0){
			System.out.println("agent:"+agent+"sells a ticket,"+numTicketToSell+" ticket left");
			numTicketToSell--;//原子操作?
		}
		System.out.println("agent:"+agent+"all done!");
	}

	public static void main(String[] args) {
		int numAgent=10;
		int numTicket=150;
		for(int agent=1;agent<=numAgent;agent++){
			TicketSeller2 thisSeller = new TicketSeller2();
			thisSeller.agent=agent;
			thisSeller.numTicketToSell=numTicket/numAgent;
			Thread thread = new Thread(thisSeller);
			thread.start();
		}
	}
}

    结果：不同售票员之间的相关售票信息无法共享，每个售票员在自顾自卖票，与TicketSeller1类似。

    1.3. 将numTicketToSell票数信息设置为static进行共享（注意：不是每个人15张票了，是150张票的信息共享）

    public class TicketSeller3 implements Runnable{
	
	public int agent;
	public static int numTicketToSell;
	
	@Override
	public void run(){
		while(numTicketToSell>0){
			System.out.println("agent:"+agent+" sells:"+numTicketToSell+" ticket");
			numTicketToSell--;
		}
		System.out.println("agent:"+agent+"all done!");
	}

	public static void main(String[] args) {
		
		int numAgent=10;
		int numTicket=150;
		for(int agent=1;agent<=numAgent;agent++){
			TicketSeller3 thisSeller = new TicketSeller3();
			thisSeller.agent=agent;
			thisSeller.numTicketToSell=numTicket;
			Thread thread = new Thread(thisSeller);
			thread.start();
		}
	}
}

    结果：解决了票数的共享，但是会出现不同售票员在售同一张票的情况。比如售票员1和售票员2 都售卖了第150号票。
    问题原因：在处理临界区数据（票数）时，未上锁。

    1.4. 加上同步锁：一个线程访问一个对象中的synchronized同步代码块时，其他试图访问该对象的线程将被阻塞。

    public class TicketSeller4 implements Runnable{
	
	public int agent;
	public static int numTicketToSell;
	public static String lock;
	//public String lock;
	
	@Override
	public void run(){
		synchronized(lock){//同步锁
			while(numTicketToSell>0){
					System.out.println("agent:"+agent+" sells:"+numTicketToSell+" ticket");
					numTicketToSell--;
			}
		}
		System.out.println("agent:"+agent+"all done!");
	}

	public static void main(String[] args) {
		int numAgent=10;
		int numTicket=150;
		String lock="mylock";
		for(int agent=1;agent<=numAgent;agent++){
			TicketSeller4 thisSeller = new TicketSeller4();
			thisSeller.agent=agent;
			thisSeller.numTicketToSell=numTicket;
			thisSeller.lock=lock;
			Thread thread = new Thread(thisSeller);
			thread.start();
		}
	}
}

    结果：1号售票员将150张票全部卖出才截止。
    问题原因：锁的粒度问题（范围过大的问题），导致要将票全部卖完才算一个seller结束。把其他不在临界区的数据也放入了锁内，导致线程效率被降低。若将synchronized放入while循环内也是相同的问题，因为不同进程在进入while的时候都已经获取了numTicketToSell的值，会导致重复或产生负票。

    1.5. 改用信号量：有无static都一样，因为所有seller对象用的都是同一个lock的String对象，指向的都是lock变量的地址。但如果将lock放入for内，就不行了。

    import java.util.concurrent.Semaphore;

public class TicketSeller5 implements Runnable{
	
	public int agent;
	public static int numTicketToSell=150;
	public static String lock;
	//public static Semaphore semaphore;  
	public  Semaphore semaphore;  
	
//	@Override
	public void run(){
		try{	
			while(true){
				int num=0;
				semaphore.acquire();
				if(numTicketToSell>0){
					num=numTicketToSell;
					numTicketToSell--;
				}
				else{
					semaphore.release();
					break;	
				}
				semaphore.release();
				System.out.println("agent:"+agent+" sells:"+num+" ticket");	
			}
		}
		catch(Exception e){}
		System.out.println("agent:"+agent+"all done!");
	}

	public static void main(String[] args) {
		
		int numAgent=10;
		//int numTicket=150;
		String lock="mylock";
		Semaphore semaphore = new Semaphore(1); 
		for(int agent=1;agent<=numAgent;agent++){
			TicketSeller5 thisSeller = new TicketSeller5();
			thisSeller.agent=agent;
			//thisSeller.numTicketToSell=numTicket;
			thisSeller.lock=lock;
			thisSeller.semaphore=semaphore;
			Thread thread = new Thread(thisSeller);
			thread.start();
		}
	}
}

    结果：150票由10位售票员并发执行。成功！

  2. 下载器问题（生产者-消费者问题）
    设置8个槽位——Size为8的数组，需要读取26个英文字母。
    2.1. 不加任何锁，只是分了读/写线程

    import java.util.concurrent.Semaphore;

class BufferChar{
	public static char[] buffer=new char[8];
}

class Witer implements Runnable{
	
	@Override
	public void run(){
		for(int i=0;i<26;i++){
			BufferChar.buffer[i%8]=(char)(i+65);
		}
	}
}

class Reader implements Runnable{
	@Override
	public void run(){
		for(int i=0;i<26;i++){
			System.out.println(BufferChar.buffer[i%8]);
		}
	}
}

public class DownLoad1{
	
		public static void main(String[] args) {
			Witer w = new Witer();
			Reader r = new Reader();
			Thread threadw = new Thread(w);
			Thread threadr = new Thread(r);
			threadw.start();
			threadr.start();
	}
}

    结果：只能重复地读到XYZSTUW这几位字母。
    问题原因：写的速度远远大写读的速度，导致8个槽位被最后的8个字母（YZSTUVWX）覆盖，第一次读的时候就已经是最后8个字母了

    2.2. 加上同步锁

    import java.util.concurrent.Semaphore;

class BufferChar{
	public static char[] buffer=new char[8];
}

class Witer implements Runnable{
	
	@Override
	public void run(){
		for(int i=0;i<26;i++){
			synchronized(BufferChar.buffer){
				BufferChar.buffer[i%8]=(char)(i+65);
			}
		}
	}
}

class Reader implements Runnable{

	@Override
	public void run(){
		for(int i=0;i<26;i++){
			synchronized(BufferChar.buffer){
				System.out.println(BufferChar.buffer[i%8]);
			}
		}
	}
}

public class DownLoad2{
		public static void main(String[] args) {
			Witer w = new Witer();
			Reader r = new Reader();
			Thread threadw = new Thread(w);
			Thread threadr = new Thread(r);
			threadw.start();
			threadr.start();
	}
}

    结果：同2.1无差别：只能重复地读到XYZSTUW这几位字母。
    问题原因：读写用的是同一个锁，所以写线程先开始的话，要等26个字母全部写入后再读。其实本质与2.1没差别，都是全部写完了再读。

    2.3. 改用信号量

    import java.util.concurrent.Semaphore;

class BufferChar{
	public static Semaphore semaphore=new Semaphore(1);  
	public static char[] buffer=new char[8];
}

class Witer implements Runnable{
	
	@Override
	public void run(){
		for(int i=0;i<26;i++){
			try{
				BufferChar.semaphore.acquire();
				BufferChar.buffer[i%8]=(char)(i+65);
				BufferChar.semaphore.release();
			}
			catch(Exception e){}
		}
	}
}

class Reader implements Runnable{

	@Override
	public void run(){
		for(int i=0;i<26;i++){
			try{
				BufferChar.semaphore.acquire();
				System.out.println(BufferChar.buffer[i%8]);
				BufferChar.semaphore.release();
			}
			catch(Exception e){}
		}
	}

}

public class DownLoad3{
		public static void main(String[] args) {
			Witer w = new Witer();
			Reader r = new Reader();
			Thread threadw = new Thread(w);
			Thread threadr = new Thread(r);
			threadw.start();
			threadr.start();
	}
}

    结果：同2.1无差别：只能重复地读到XYZSTUW这几位字母。
    问题原因：读写用的是同一个信号量。由于写线程先开始，速度远远大于读线程。其实本质与2.1没差别，都是全部写完了再读。

    2.4. 改用两个信号量
    设置写线程的empty信号量，表示槽位空闲值，初始为8；当槽位有空闲才能写，写完释放读线程信号量。读线程full信号量表示写操作时不能进行读操作。由于先写再读，所以full信号量初始为0，不能读，要先写入才行。
    个人理解：整体相当于，在不被读的情况下，写操作最多执行八次。将槽位全部填充满后，就无法在执行写操作。同步地，被读之后就多出一个空位，就可以继续执行写操作。从而实现了，26个字母的顺序写和读。

    import java.util.concurrent.Semaphore;

class BufferChar{
	public static Semaphore empty=new Semaphore(8);
	public static Semaphore full=new Semaphore(0);
	public static char[] buffer=new char[8];
}

class Witer implements Runnable{
	
	@Override
	public void run(){
		for(int i=0;i<26;i++){
			try{
				BufferChar.empty.acquire();
				BufferChar.buffer[i%8]=(char)(i+65);
				BufferChar.full.release();
			}
			catch(Exception e){}
		}
	}
}

class Reader implements Runnable{

	@Override
	public void run(){
		for(int i=0;i<26;i++){
			try{
				BufferChar.full.acquire();
				System.out.println(BufferChar.buffer[i%8]);
				BufferChar.empty.release();
			}
			catch(Exception e){}
		}
	}
}

public class DownLoad4{
		public static void main(String[] args) {
			Witer w = new Witer();
			Reader r = new Reader();
			Thread threadw = new Thread(w);
			Thread threadr = new Thread(r);
			threadw.start();
			threadr.start();
	}
}

    结果：26个英文字母实现了顺序写读。
    注意：empty=new Semaphore(8)；empty的初始值不一定要设成8。大于0 小于8都可以，但是会导致空间浪费。若empty=new Semaphore(1)，相当于只能写入1个字符，要等被读掉才可以继续写。

  3. 哲学家吃饭问题
    假设，圆形饭桌上共有5个哲学家准备吃饭，每个人左右两边各1根筷子。
    初始化筷子的信号值数组，每根筷子都是可以被获取的。允许饭桌上最大的同时进餐人数为4。（5就会产生死锁）

    import java.util.concurrent.Semaphore;

class BufferSomething{
	public static Semaphore[] kuaiZi={new Semaphore(1),new Semaphore(1),new Semaphore(1),
									  new Semaphore(1),new Semaphore(1)};
	public static Semaphore allowEat=new Semaphore(4);
}

class Phi implements Runnable{
	public int phiId;
	 
	@Override
	public void run(){
		try{	
			for(int i=0;i<1000;i++){ //饭桌上每个人的吃饭次数
				BufferSomething.allowEat.acquire();
				BufferSomething.kuaiZi[phiId].acquire();
				BufferSomething.kuaiZi[(phiId+1)%5].acquire();
				System.out.println("phi:"+phiId+" eating and stop thinking");
				BufferSomething.kuaiZi[phiId].release();
				BufferSomething.kuaiZi[(phiId+1)%5].release();
				BufferSomething.allowEat.release();
				System.out.println("phi:"+phiId+" eated and start thinking");
			}
			System.out.println("All Done!");
		}
		catch(Exception e){
			System.out.println("error!!!");
		}
	}
}

public class PhiProblem{
	public static void main(String[] args) {
		for(int i=0;i<5;i++){
			Phi phi=new Phi();
			phi.phiId=i;
			Thread phiThread=new Thread(phi);
			phiThread.start();
		}
	}
}

    结果：不会产生死锁。

  4. 手工艺店铺管理问题
    整个流程为：顾客告诉店员要多少产品，店员（店员和产品一对一）一个一个完成制造，经理审核好该产品后告诉店员产品质量ok不，如果不ok的话店员继续制造，ok交给顾客。
    直到所有工艺品都被完成交给顾客，顾客结账给收银员后走人。
    因此，顾客和店员的个数相同，收银员和经理各一位。有顾客才需要店员，所以店员线程是在顾客类方法中创建的。而顾客、收银员、经理是一定存在的，就在main方法里面。

    import java.util.concurrent.Semaphore;
import java.util.Random;

//手工艺品
class Craft{

	public static int passed=0;
	public static Semaphore requestinspection = new Semaphore(0); 
	public static Semaphore finishinspection = new Semaphore(0); 
	public static Semaphore managerlock = new Semaphore(1); 

}

//收银员
class Cashier implements Runnable{

	public static int number=0;
	public static Semaphore numberlock=new Semaphore(1);
	public static Semaphore cashierrequested=new Semaphore(0);
	public static Semaphore customers[]={new Semaphore(0),new Semaphore(0),new Semaphore(0),
	                                     new Semaphore(0),new Semaphore(0),new Semaphore(0),
										 new Semaphore(0),new Semaphore(0),new Semaphore(0),
										 new Semaphore(0)};

	@Override
	public void run(){
		try{	
			for(int i=0;i<10;i++){
				//等待顾客
				cashierrequested.acquire();
				System.out.println(i+":checked out");
				customers[i].release();
			}	
		}catch(Exception e){
			System.out.println("error!!!");
		}
	}
}

//顾客
class Customer implements Runnable{

	public int numCrafts;
	public int customerid;

	@Override 
	public void run(){
		try{	
			System.out.println(customerid+": customer entry shop");
			for(int i=0;i<numCrafts;i++){
				Service service=new Service();
				service.customerid=customerid;
				Thread serviceThread = new Thread(service);
				//一个产品 启动一个店员 去制作产品
				serviceThread.start();
				System.out.println(customerid+": customer comsune "+i+" craft,total:"+numCrafts);
			}
			for(int i=0;i<numCrafts;i++){
				//等待店员做完一个产品
				Service.servicedone.acquire();
				System.out.println(customerid+": customer get "+i+" craft,total:"+numCrafts);
			}
			System.out.println(customerid+": customer start checkout");
			// 收银员一次只接待一位顾客
			Cashier.numberlock.acquire();
			int number=Cashier.number++;
			Cashier.numberlock.release();
			//让
			Cashier.cashierrequested.release();
			//等待收银员结算完 第number位顾客就结束了 即整个流程结束
			Cashier.customers[number].acquire();
			
		}catch(Exception e){
			System.out.println("error!!!");
		}
	}
}

//经理
class Manager implements Runnable{

	public static int approved=0;
	public static int inspected=0;

	@Override
	public void run(){
		try{	
			while(approved<HandmadeShop.total){ //审查通过的产品数小于总的产品数
				//等待产品的申请
				Craft.requestinspection.acquire();
				inspected++;
				Craft.passed=new Random().nextInt(2);
				if(Craft.passed==1){
					approved++;
				}
				Craft.finishinspection.release();
			}
		}catch(Exception e){
			System.out.println("error!!!");
		}
	}
}

//店员
class Service implements Runnable{
	
	public int customerid;
	public static Semaphore servicedone=new Semaphore(0);

	@Override
	public void run(){
		try{	
			int passed=0;
			while(passed==0){ //直到店员将该产品制作成功
				System.out.println("Make Drink for customer:"+customerid);
				//每做完一个产品 就给经理审核 并且 经理一次只能审核一个产品
				Craft.managerlock.acquire();
				Craft.requestinspection.release();
				//等待经理审核结束
				Craft.finishinspection.acquire();
				passed=Craft.passed;
				Craft.managerlock.release();
			}
			//店员做完该产品
			servicedone.release();
		}
		catch(Exception e){
			System.out.println("error!!!");
		}
	}
}

public class HandmadeShop{
	public static int total=0;
	public static void main(String[] args) {
		for(int i=0;i<10;i++){ //假设共有10位顾客
			Customer customer=new Customer();
			int numCrafts = new Random().nextInt(4) + 1; //每位顾客需要的产品数量
			customer.numCrafts=numCrafts;
			customer.customerid=i;
			Thread customerThread = new Thread(customer);
			customerThread.start();
			total=total+numCrafts;	//总产品量
		}
		Cashier cashier=new Cashier();
		Thread cashierThread=new Thread(cashier);
		cashierThread.start();
		Manager manager=new Manager();
		Thread managerThread=new Thread(manager);
		managerThread.start();
	}
}

    结果：不会产生死锁。

是橙汁啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代理模式（简要介绍）
kdsnace的博客
07-08 1697
通过例子和代码简单介绍静态代理模式和动态代理模式的优缺点和使用。
Unity-ML-Agents-Soccer Twos环境(1)-SoccerEnvController.cs
aaaccc444的博客
04-26 1149
1.SoccerEnvController.cs 1.1 导入命名空间 1.2SoccerEnvController 类 1.3 PlayerInfo类 1.4XML 注释标签 1.5 定义字段 1.6Start() 方法 1.7FixedUpdate()方法 1.8ResetBall()方法 1.9GoalTouched()方法 1.10ResetScene() 方法
设计模式总结
black mamba
10-11 266
单例模式 工厂模式 最熟悉的其余两种模式？
FileSystemXmlApplicationContext方法的绝对路径问题
weixin_34138377的博客
06-27 294
public AgentServer(Socket c,String confDir) { this.client = c; ApplicationContext ac = new FileSystemXmlApplicationContext(confDir); this.atsMgr = (AtsMgr) ac.getBean("atsMgr");} 用FileSy...
YARN Service的原理及应用
houzhizhen的专栏
03-02 1954
Service Type AbstratService CompositeService Service Example class Agent { private final int id; public Agent(int id) { this.id = id; } // hashCode and equals method mus...
Tensorflow分布式原理理解
01-27
本文来自于网络，本文章主要通过介绍Tensorflow的训练模型和Tensorflow的分布式结构与计算，阐述了Tensorflow的实现原理,希望对您的学习有所帮助。实现原理图1.1TensorFlow单机版本和分布式版本的示例图TensorFlow...
分布式原理源码解析
04-06
分布式技术，分布式ID，分布式锁，分布式事务，CAP，BASE等
代理模式详解及源码分析
qq_50278146的博客
11-16 904
代理模型详解，代理模式源码，动态代理，java动态代理实例，静态代理，动态代理源码。
axios,json...总结
lidan724的博客
03-19 632
axios请求 首先安装axios, 方法一：npm install axios 方法二： CDN引入 　　 get请求： //1.get请求(无参数) axios.get('http://www.xxx') .then(function(response){ //请求成功 }).catch(function(erroe){ //请求失败...
分布式计算模型详解：MapReduce、数据流、P2P、RPC、Agent
最新发布
Shockang的博客
06-29 1379
本文主要介绍了以下五种分布式计算模型的详细解释： 1. MapReduce：介绍了Google提出的MapReduce模型，包括Map阶段和Reduce阶段的功能和特点，以及在处理大规模数据集中的应用。 2. 数据流：介绍了数据流计算模型，将计算任务看作是一系列数据流的处理过程，适用于实时处理大量数据的场景，具有时序语义和流控制等特点。 3. P2P：介绍了P2P计算模型，其中计算任务由多个节点协同完成，节点之间可以直接通信，具有高度的可扩展性和弹性，常用于分布式存储和分布式计算等。 4. RPC：介绍了
javaagent获得每个方法的执行时间
yang_zzu的博客
06-15 1965
比如说在对项目的每个方法的执行时间进行监控的需求的时候，不可能对项目中成千上万的方法一个一个的进行处理，当然如果时间要求很宽松的可以 一个一个的进行添加处理。 但是使用字节码插桩的方法，可以比较方便的进行需求的实现。 拦截的时候使用的是 javaagent 编辑、修改 class 字节码文件的时候使用的是 javassist 技术 在引入 javassist 的jar包的时候，尽可能的选择高版本的jar包 <dependency> <groupId>javassi
java代理模式探索
阵雨的博客
10-31 329
代理是为了控制对被代理人的访问，代理关系常见经纪人和演员之间，双方的职责解耦。 场景一：静态代理 public interface Performance { public void sing(String name); } public class Actor implements Performance{ @Override public void sin...
Zabbix分布式监控系统
kt1121540074的博客
11-20 1459
Zabbix分布式监控系统 基础环境配置 主机名配置 一台server节点和一台agent节点，使用secureCRT进行连接。 Server节点修改主机名为zabbix-server： [root@localhost ~]# hostnamectl set-hostname zabbix-server 修改完之后重新连接secureCRT，并查看主机名： [root@zabbix-server ~]# hostnamectl Static hostname: zabbix...
14-分布式压测
sunny10189的博客
09-24 889
一、分布式压测原理 1、原理 分布式压测分为两块：控制器（controller）和代理（agent） controller负责把脚本分发给agent执行； agent负责执行脚本，产生对服务器的实际压力，agent运行 non GUI model，点击jmeter-server.bat即可。agent执行脚本后，把压测的结果发送给controller。 controller作为控制器不加入实际测试，只负责发送和收集agent信息。 二、window配置 1、配置agent （1）修改jmete
分布式之agent
Daisy Liu's Column
03-30 1284
Agent的简单运用，实现卖旗子代理。这个代码实现的要求如下，这个做了很久了，突然想到，才整理出来贴出来。没法翻译，将就着看吧，看英文多了，其实觉得还不错啦。There is a buyer who wants to buy a specific flag from one or two seller agents who are trying to offer the best (low
YARN Dispatcher的原理和应用
houzhizhen的专栏
03-02 1148
AsyncDispatcher Architecture AsyncDispatcher Example Enum AgentEventType public enum AgentEventType { REGISTER, UNREGISTER, EXPIRED, HEARTBEAT, JOBLAUNCH, JOBKILL } ...
雨刷程序参考代码2
GamesDuan的专栏
04-12 5407
设计类图：抽象控制杆类：public abstract class AbstractLever { protected int lever = 1; protected int maxlever = 0; public AbstractLever() { lever = 1; } public int getMaxLever() { return maxlever
从代理机制到Spring AOP
weixin_33881050的博客
09-07 318
这篇文章准备从Java的代理机制讲到Spring的AOP。 1.代理模式 代理模式是很常见的一种设计模式，代理一词拆开来看就是代为受理，那显然是要涉及到请求被代理的委托方，提供代理的代理方，以及想要通过代理来实际联系委托方的客户三个角色。举个生活中很常见的例子，各路的明星都会有个自己的经纪人来替自己打点各种各样的事情，这种场景下，明星本身是委托方，经纪人是代理方，明星把自己安排演出、出席见面会的时...
xxljob 分布式原理
05-19
XXL-Job 是一个轻量级分布式任务调度平台，其分布式原理主要包括以下几点： 1. 任务分片：任务分片是 XXL-Job 实现任务分布式执行的基础。在任务被提交时，XXL-Job 会将任务分成多个子任务，每个子任务独立执行。分片可以按照数据切分、时间切分等方式进行。 2. 执行器注册：执行器是任务的具体执行者，它们负责执行任务分片。在 XXL-Job 中，执行器需要先向调度中心注册，告诉调度中心自己的 IP、端口、执行器名称等信息，以便调度中心能够将任务分配给它。 3. 调度器调度：调度器是 XXL-Job 的核心组件，它负责将任务分配给可用的执行器。调度器会根据任务的优先级、分片情况、执行器负载等因素进行任务调度。 4. 任务日志：为了方便任务的追踪和排查问题，XXL-Job 提供了任务日志功能。执行器会将任务执行过程中的日志上传到调度中心，用户可以通过调度中心查看任务执行日志。 总之，XXL-Job 通过任务分片、执行器注册、调度器调度和任务日志等机制来实现分布式任务调度。这些机制有效地提高了任务的执行效率和稳定性，能够满足大规模分布式任务调度的需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值