线程数据共享与协作

最新推荐文章于 2024-07-27 21:00:56 发布
最新推荐文章于 2024-07-27 21:00:56 发布
阅读量334 收藏
点赞数
分类专栏： Java基础 文章标签： Java Java基础 Java语法 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_35302939/article/details/94358990
版权

线程数据共享与协作

线程数据共享

  • 数据（即任意的对象）在多个线程之间的共享

方式一：构造方法传入共享数据（对象）

测试类

public class ThreadShareDataTest {
	public static void main(String[] args) {
		Object object = new Object();
		NewThread newThread1 = new NewThread(object);
		NewThread newThread2 = new NewThread(object);
		newThread1.start();
		newThread2.start();
	}
}

线程类

class NewThread extends Thread{
	Object object;
	public NewThread(Object object) {
		this.object = object;
	}
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName() + object + "--->" + i);
		}
	}
}

结果：在两个线程之间是同一个对象，这样就实现了数据的共享

Thread-0java.lang.Object@2b8a94a4—>0
Thread-1java.lang.Object@2b8a94a4—>0
Thread-0java.lang.Object@2b8a94a4—>1
Thread-1java.lang.Object@2b8a94a4—>1
Thread-0java.lang.Object@2b8a94a4—>2
Thread-1java.lang.Object@2b8a94a4—>2
Thread-1java.lang.Object@2b8a94a4—>3
Thread-1java.lang.Object@2b8a94a4—>4
Thread-0java.lang.Object@2b8a94a4—>3
Thread-1java.lang.Object@2b8a94a4—>5
Thread-0java.lang.Object@2b8a94a4—>4
Thread-1java.lang.Object@2b8a94a4—>6
Thread-0java.lang.Object@2b8a94a4—>5
Thread-0java.lang.Object@2b8a94a4—>6
Thread-0java.lang.Object@2b8a94a4—>7
Thread-1java.lang.Object@2b8a94a4—>7
Thread-0java.lang.Object@2b8a94a4—>8
Thread-1java.lang.Object@2b8a94a4—>8
Thread-0java.lang.Object@2b8a94a4—>9
Thread-1java.lang.Object@2b8a94a4—>9

方式二：在线程类中定义静态成员变量

  • 在线程类中定义一个静态的成员变量，可以通过类名给变量赋值

测试类

public class ThreadShareDataTest {
	public static void main(String[] args) {
		NewThread newThread1 = new NewThread();
		NewThread newThread2 = new NewThread();
		NewThread newThread3 = new NewThread();
		ExecutorService executorService = Executors.newFixedThreadPool(2);
		executorService.submit(newThread1);
		executorService.submit(newThread2);
		executorService.submit(newThread3);
		executorService.shutdown();
	}
}

线程类

class NewThread extends Thread{
	static Object object = new Object();
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(currentThread().getName()+ "--->" + getName() + "--->" + object + "--->" + i);
		}
	}
}

结果

pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>0
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>0
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>1
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>2
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>1
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>3
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>2
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>4
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>3
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>4
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>5
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>5
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>6
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>7
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>8
pool-1-thread-2—>Thread-1—>java.lang.Object@309d7a5a—>9
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>6
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>0
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>7
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>8
pool-1-thread-1—>Thread-0—>java.lang.Object@309d7a5a—>9
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>1
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>2
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>3
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>4
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>5
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>6
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>7
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>8
pool-1-thread-2—>Thread-2—>java.lang.Object@309d7a5a—>9

synchronized

  • 上面打印出的结果有交叉执行的现象，为了使原本并发运行的多个线程实现串行运行，即多线程间同步执行，需要通过对象锁机制来实现，synchronized就是一个利用锁实现线程同步的关键字。

对需要同步的代码，使用synchronized环绕

class NewThread extends Thread{
	Object lock;
	public NewThread(Object lock) {
		this.lock = lock;
	}
	@Override
	public void run() {
		//lock变量就是共享的数据
		synchronized (lock) {
			for (int i = 0; i < 10; i++) {
				System.out.println(getName() + "--->" + lock + "--->" + i);
			}
		}
	}

测试类

public class ThreadShareDataTest {
	public static void main(String[] args) {
		Object lock = new Object();
		NewThread newThread1 = new NewThread(lock);
		NewThread newThread2 = new NewThread(lock);
		NewThread newThread3 = new NewThread(lock);
		newThread1.start();
		newThread2.start();
		newThread3.start();
	}
}

结果

Thread-0—>java.lang.Object@434e2b1d—>0
Thread-0—>java.lang.Object@434e2b1d—>1
Thread-0—>java.lang.Object@434e2b1d—>2
Thread-0—>java.lang.Object@434e2b1d—>3
Thread-0—>java.lang.Object@434e2b1d—>4
Thread-0—>java.lang.Object@434e2b1d—>5
Thread-0—>java.lang.Object@434e2b1d—>6
Thread-0—>java.lang.Object@434e2b1d—>7
Thread-0—>java.lang.Object@434e2b1d—>8
Thread-0—>java.lang.Object@434e2b1d—>9
Thread-1—>java.lang.Object@434e2b1d—>0
Thread-1—>java.lang.Object@434e2b1d—>1
Thread-1—>java.lang.Object@434e2b1d—>2
Thread-1—>java.lang.Object@434e2b1d—>3
Thread-1—>java.lang.Object@434e2b1d—>4
Thread-1—>java.lang.Object@434e2b1d—>5
Thread-1—>java.lang.Object@434e2b1d—>6
Thread-1—>java.lang.Object@434e2b1d—>7
Thread-1—>java.lang.Object@434e2b1d—>8
Thread-1—>java.lang.Object@434e2b1d—>9
Thread-2—>java.lang.Object@434e2b1d—>0
Thread-2—>java.lang.Object@434e2b1d—>1
Thread-2—>java.lang.Object@434e2b1d—>2
Thread-2—>java.lang.Object@434e2b1d—>3
Thread-2—>java.lang.Object@434e2b1d—>4
Thread-2—>java.lang.Object@434e2b1d—>5
Thread-2—>java.lang.Object@434e2b1d—>6
Thread-2—>java.lang.Object@434e2b1d—>7
Thread-2—>java.lang.Object@434e2b1d—>8
Thread-2—>java.lang.Object@434e2b1d—>9

虽然可能多次运行的线程的运行顺序可能不同，但是只要在一个线程拿到对象锁之后，其他线程就需要等待，在一个线程执行完之后释放锁之后，再开始另外一个线程。

  • 线程之间数据共享的意义也在于多个线程之间持有的锁对象是同一个对象，这样多个线程就实现了串行执行，不会出现交叉执行的现象，否则多个线程之间持有的锁对象不是同一个对象，将无法串行化。

  • 锁对象其实也可以是Class类对象，使用 类名.class或Class.forName(“全类名”)或者 对象.getClass() 由于Class类的构造方法是私有的，且为单例模式，所以使用类名.class 作为锁对象也是可以的。

线程协作

wait()方法

  • 对象锁调用了wait()方法会使当前持有该对象锁的线程处于线程等待状态同时该线程释放对对象锁的控制权，直到在其他线程中该对象锁调用notify()方法或notifyAll()方法时等待此对象锁的线程才会被唤醒

notify()方法

  • 对象锁调用notify()方法就会唤醒在此对象锁上等待的单个线程

notifyAll()方法

  • 对象锁调用notifyAll()方法就会唤醒在此对象锁上等待的所有线程；调用notifyAll()方法并不会立即激活某个等待线程，它只能撤销等待线程的中断状态，这样它们就能够在当前线程退出同步方法或同步代码块法后与其它线程展开竞争，以争取获得资源对象来执行

线程之间的协作

public class ThreadTogetherWorkTest {
	Date time;
	public static void main(String[] args) {
		ThreadTogetherWorkTest threadTogetherWorkTest = new ThreadTogetherWorkTest();
		TimeThread timeThread =threadTogetherWorkTest.new TimeThread();
		DisplayTimeThread displayTimeThread = threadTogetherWorkTest.new DisplayTimeThread();
		timeThread.start();
		displayTimeThread.start();
		
	}

	class TimeThread extends Thread{
		@Override
		public void run() {
			time = new Date();
		}
	}
	
	class DisplayTimeThread extends Thread{	
		@Override
		public void run() {
			System.out.println(time);
		}
		
	}
}

执行结果
有可能为 (displayTimeThread线程先夺取到了CPU的执行权)

null

或者为（timeThread线程先夺取到了CPU的执行权）

Mon Jul 01 17:26:45 CST 2019

  • 为了一定可以打印出时间信息需要线程之间的协作

方式一

  • 使用join
public class ThreadTogetherWorkTest {
	Date time;
	public static void main(String[] args) {
		ThreadTogetherWorkTest threadTogetherWorkTest = new ThreadTogetherWorkTest();
		TimeThread timeThread =threadTogetherWorkTest.new TimeThread();
		DisplayTimeThread displayTimeThread = threadTogetherWorkTest.new DisplayTimeThread(timeThread);
		timeThread.start();
		displayTimeThread.start();		
	}

	class TimeThread extends Thread{
		@Override
		public void run() {
			time = new Date();
		}
	}
	
	class DisplayTimeThread extends Thread{
		TimeThread timeThread;
		public DisplayTimeThread(TimeThread timeThread) {
			this.timeThread = timeThread;
		}
		
		@Override
		public void run() {
			if(time==null) {
				try {
					timeThread.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println(time);
		}
		
	}
}

方式二

  • 使用synchronized执行同步代码块，配合wait和notify方法
public class ThreadTogetherWorkTest {
	Date time;
	public static void main(String[] args) {
		ThreadTogetherWorkTest threadTogetherWorkTest = new ThreadTogetherWorkTest();
		TimeThread timeThread =threadTogetherWorkTest.new TimeThread();
		DisplayTimeThread displayTimeThread = threadTogetherWorkTest.new DisplayTimeThread();
		timeThread.start();
		displayTimeThread.start();
		
	}

	class TimeThread extends Thread{
		@Override
		public void run() {
			time = new Date();
			synchronized (ThreadTogetherWorkTest.class) {
				ThreadTogetherWorkTest.class.notify();
			}
		}
	}
	
	class DisplayTimeThread extends Thread{
		@Override
		public void run() {
			if(time==null) {
				synchronized (ThreadTogetherWorkTest.class) {
					try {
						ThreadTogetherWorkTest.class.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			System.out.println(time);
		}
	}
}

结果

Mon Jul 01 17:34:44 CST 2019

注意：wait方法和sleep方法的区别

  1. wait方法非静态但是是Object的方法;sleep是Thread的静态方法
  2. wait方法要配合synchronized以及notify使用；sleep不需要
  3. 执行wait方法时当前线程进入阻塞状态，并且释放对象锁；执行sleep方法当前线程虽然也会进入阻塞状态，但是并不释放对象锁
【Java 线程系列】Java线程之间的共享和协作
半身风雪
05-23 1274
线程基础、线程之间的共享和协作前言一、进程和线程1、进程是程序运行资源分配的最小单位2、线程是CPU 调度的最小单位，必须依赖于进程而存在3、线程无处不在二、CPU 核心数和线程数的关系1、多核心2、多线程3、核心数、线程数三、CPU 时间片轮转机制四、并行和并发1、并发2、并行五、高并发编程1、CPU 资源利用的充分2、加快用户响应时间3、使代码模块化、异步化、简单化六、多线程注意事项1、线程之间的安全性2、线程之间的死锁3、线程多了会将服务资源耗尽形成死机、当机总结 前言 在系列文章开始之前，我们首先
并发编程（一）：线程基础、线程之间的共享与协作
nelson的博客
08-26 3194
一、基础概念 1.1 CPU核心数、线程数 **两者的关系：**cpu的核心数与线程数是1:1的关系，例如一个8核的cpu，支持8个线程同时运行。但在intel引入超线程技术以后，cpu与线程数的关系就变成了1:2。此外在开发过程中并没感觉到线程的限制，那是因为cpu时间片轮转机制（RR调度）的算法的作用。什么是cpu时间片轮转机制看下面1.2. 1.2 CPU时间片轮转机制 **含义...
第一节 线程基础、线程之间的共享和协作01
wen_005的博客
02-21 197
  一、相关慨念 1.1、cpu核心数和线程的关系 一般情况下cpu的核心数等于线程数，如8核的cpu支持8个线程同时运行，在intel引入超线程技术以后，cpu核心数:线程数等于1:2的关系。 一般情况下，核心数:线程数=1:1；使用了超线程技术后 1:2 1.2、cpu时间片轮转机制 在开发中体会不到有几个线程存在，这是因为存在cpu时间片轮转机制（RR调度），即给每一个进程分配一...
Android架构师必备技能 | 并发编程之线程共享和协作（上）
qq_44102588的博客
09-09 201
目录一，CPU核心数，线程数，时间片轮转机制解读1. 名称说明2. 基础概念：进程和线程3. CPU核心数和线程数的关系4. CPU时间片轮转机制5. 查看 CPU 信息二，实现线程共享1. synchronizad2. volatile3. ThreadLocal 一，CPU核心数，线程数，时间片轮转机制解读 1. 名称说明 CPU 个数： 是指物理上，也及硬件上的核心数； 核数： 是逻辑上的，简单理解为逻辑上模拟出的核心数； 线程数： 是同一时刻设备能并行执行的程序个数，如果没有超线程技术，
数据协同是什么
weixin_43018397的博客
11-08 5639
数据协同就是数据共享加多方计算生成数据协同网络，解决用户问题。而这个网络最重要的几点就是可信存储、安全计算。具体怎么实现呢？ 首先可信存储就是要让数据的存储过程值得信赖，因此，良好的数据结构，存储方式，以及可溯源改动的数据存储方式就是可值得信赖的，如1、可实时监管数据的完整性，满足数据可溯源、可审计的需求。2、保证数据在存储过程中高可用、可扩展，及可通过数据备份的方式，减少数据灾难，断点不可续、...
大数据协作框架
weixin_30614109的博客
05-20 108
Sqoop http://sqoop.apache.org/docs/1.4.6/SqoopUserGuide.html#_introduction Flume http://flume.apache.org/documentation.html Oozie http://oozie.apache.org/ Hue http://cloudera.github.io...
第20章 Part3 多线程互斥与协作.pdf
10-21
### 第20章 Part3：多线程互斥与协作 #### 一、互斥（Mutual Exclusion） 互斥是指在线程编程中确保多个线程不会同时访问同一资源的技术。这种技术非常重要，因为如果不加以控制，多个线程对共享资源的并发访问...
笔记-1、线程基础、线程之间的共享和协作2
08-08
对于线程间共享和协作，Java提供了多种机制。`synchronized`关键字用于实现内置锁，保证同一时间只有一个线程访问共享资源，防止数据不一致。类锁锁定的是类的Class对象，而对象锁锁定的是实例对象。`volatile`...
线程间数据传递：深入探索Java中的数据共享技术
全栈工程师，热爱编程，喜欢探索各种技术栈。分享前端、后端、数据库等技术学习心得，以及在项目开发中的实践经验。
07-27 631
在Java中，线程间的数据传递有多种实现方式，选择合适的方案取决于具体的应用场景和性能需求。共享对象适用于简单的线程间数据传递，但需要注意同步问题。volatile关键字适用于状态标志或信号量，避免了锁操作。线程通信通过waitnotify机制实现线程间的协调和协作。并发集合提供了高效的线程安全集合类，适用于高并发场景。**和Future**简化了线程池管理和异步任务的结果获取。****提供了强大的异步编程支持，可以方便地实现非阻塞式操作。
Java中线程同步和线程协作学习笔记
05-27
在Java编程中，线程同步和线程协作是多线程编程的重要概念，确保了在并发环境下程序的正确性和数据的一致性。线程同步的主要目标是解决线程安全问题，即在多线程访问共享资源时避免数据的混乱，保证程序的可再现性。...
大数据协作框架介绍
Z_Data的博客
11-13 442
在hadoop生态领域中协作框架主要分为以下四种： 1、sqoop：关系型数据库，导入导出到hdfs、hive、hbase 2、Fiume：日志收集框架，主要收集日志服务器上产生的文件 3、Oozie： 任务调度框架。在yran上提交的任务有很多。每个任务什么时候运行该如何运行都是需要调度的 4 Hue: 可视化工具...
并发编程之线程共享和协作（一）
AndroidAlvin的博客
11-04 297
更多Android架构进阶视频学习请点击：https://space.bilibili.com/474380680 本篇文章将从以下几个内容来阐述线程共享和协作: [基础概念之CPU核心数、线程数，时间片轮转机制解读] [线程之间的共享] [线程间的协作] 一、基础概念 CPU核心数、线程数 两者的关系：cpu的核心数与线程数是1:1的关系，例如一个8核的cpu，支持8个线程同...
多线程：线程之间的共享和协作（一）
你能找到这里，说明你有经天纬地之才，扭转乾坤只能，鬼神不测之计包藏宇宙之志，真乃乱世之枭雄，治世之能臣也
04-14 589
1.线程之间的共享和协作 1.1什么是进程：进程是操作系统进行资源分配的最小单位,其中资源包括:CPU、内存空间、 磁盘 IO 等,同一进程中的多条线程共享该进程中的全部系统资源,而进程和进程 之间是相互独立的。 1.2什么是线程：线程是 CPU 调度的最小单位,必须依赖于进程而存在。 2.并行和并发的概念： 并行：同时执行不同的任务；并发：不能脱离时间单位，交替...
数据协作如何解决大数据的大问题
中琛魔方大数据
03-20 545
　　越来越多的数据协作解决方案提供商争相应对IT管理中企业数据碎片的挑战。问题是，孤立的团队希望使用大型数据集，包括来自其他团队的数据，因此，制作和共享数据副本会增加在企业中存储和管理多个相同数据副本的成本。 　　进入数据协作，这是一种相对较新的方法，正在撼动大数据管理，并且处于数据驱动型决策的最前沿。数据协作使多方可以共享对他们数据的访问，这使各方可以更全面地了解项目，并获得更深刻的见解...
大数据协作框架之Flume
象在舞的技术专栏
08-12 601
一、Flume概述        Flume是一个分布式的，可靠的，可用的，非常有效率的对大数据量的日志数据进行收集、聚集、移动信息的服务。Flume仅仅运行在Linux环境下。       它是一个基于流式的数据的非常简单的（只需要写一个配置文件）、灵活的架构，它也是一个健壮的、容错的。它用一个简单的扩展数据模型用于在线实时应用分析。它的简单表现为：写个source、channel、sink
为什么我们用的系统这么烂？
weixin_33860722的博客
12-26 177
开篇小故事 　　下面的故事都是真实的，犹如雷同纯属同类，请仔细反思。 　　故事1：升级硬件 　　客户后台数据库存在性能问题，查询特别慢，长时间语句很多。客户因此而苦恼，咨询了软件厂商我该怎么办？软件厂商给出的答案：升级硬件吧，现在的资源不能满足了！ 　　那么客户是什么硬件配置呢？数据库什么体量呢？ 　　答：128的CPU、512的内存、高端的存储，跑了一个200G数据量的库，好像硬件满满...
day41-python多进程多线程-多线程共享
weixin_34250709的博客
12-14 110
线程共享变量多线程和多进程不同之处在于多线程本身就是可以和父进程共享内存的，这也是为什么其中一个线程挂掉以后，为什么其他线程也会死掉的道理。 import threading def worker(): l.append("wxp") l.append("wxx") l.append("wpp") if __name__ == "__main...
讲义整理-线程基础、线程之间的共享和协作
Rick1024
04-19 313
讲义整理-线程基础、线程之间的共享和协作线程基础、线程之间的共享和协作什么是进程和线程CPU核心数和线程数的关系CPU时间片轮转机制澄清并行和并发高并发编程的意义、好处和注意事项多线程程序需要注意事项 线程基础、线程之间的共享和协作 什么是进程和线程 进程是程序运行资源分配的最小单位 进程是操作系统进行资源分配的最小单位,其中资源包括:CPU、内存空间、磁盘 IO 等,同一进程中的多条线程共享该进程中的全部系统资源,而进程和进程之间是相互独立的。进程是具有一定独立功能的程序关于某个数据集合上的一次运行
linux多线程socket通信与互斥量
PPprogrammer的博客
01-29 746
什么是线程 每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程，可以把线程称作程序执行流的最小单位。每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。可以用下面的图表示，更加直观，协程是更加轻量级的线程，这里就不叙述了。 单线程与多线程 单线程：单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行...
线程与进程数据共享的优劣
最新发布
03-09
### 线程与进程的数据共享 #### 线程间数据共享的优势和劣势 线程作为同一进程中执行流的部分，能够方便地访问该进程内的全局变量和其他资源。这种特性使得线程间的通信变得简单高效。 - **优势** - 高效性：由于线程属于同一个进程空间，因此可以直接读写相同的内存区域而无需复杂的传递机制[^1]。 - 资源利用率高：减少了因跨进程边界传输所需的时间成本以及额外的缓冲区管理开销[^4]。 - **劣势** - 同步难题：多个线程可能同时尝试修改相同位置的数据，这就要求开发者精心设计锁机制或其他形式的互斥控制来防止竞争条件的发生[^5]。 ```python import threading lock = threading.Lock() def thread_safe_operation(): with lock: # Critical section code here pass ``` #### 进程间数据共享的优势和劣势 相比之下，不同进程之间拥有独立地址空间，默认情况下无法直接相互作用；然而，Linux 提供了几种有效的IPC（Inter-process Communication）手段用于实现安全可靠的信息交换。 - **优势** - 安全隔离度好：每个进程都有自己私有的虚拟地址范围，即使某个子系统崩溃也不会影响到其他部分的工作稳定性。 - 易于调试维护：因为各个组件相对封闭，在出现问题时更容易定位错误源头并加以修复。 - **劣势** - 实现复杂度较高：为了使两个或更多个分离实体可以协作完成特定功能，则必须采用诸如管道、消息队列或者套接字等方式来进行必要的沟通协调工作[^2]。 - 效率较低：相比于简单的指针指向目标对象而言，这些间接的方法通常伴随着更大的延迟及更多的计算负担[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值