弹性分布式数据集RDD详细说明

于 2024-10-07 09:56:31 发布
阅读量516 收藏 9
点赞数 26
分类专栏： 大数据相关技术 文章标签： 分布式 RDD spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wendao76/article/details/142735322
版权

文章目录

整体介绍

弹性分布式数据集RDD（Resilient Distributed Dataset）是Apache Spark中最基本的数据抽象，代表一个不可变、可分区、元素可以并行计算的数据集合。以下是对RDD的详细说明：

一、定义与特性

  1. 定义：RDD是Spark对数据集的抽象，用于存放数据，它表示一个只读的、可分区的、其中元素可进行并行计算的集合，并且是可跨越集群节点进行并行操作的有容错机制的集合。

  2. 特性：

    • 基于内存计算：RDD通过将数据加载到内存中，提高了数据处理的效率。相比于传统的磁盘存储，内存（RAM）的读写速度更快，因此RDD适用于需要快速迭代计算的任务。
    • 惰性计算：RDD的转换操作是惰性的，即它们不会立即执行，而是等到真正需要结果时才触发计算。这种机制使得Spark能够优化执行计划，提高性能。
    • 容错性：RDD采用基于血缘的高效容错机制。在RDD的设计中，数据是只读的不可修改，如果需要修改数据，必须从父RDD转换生成新的子RDD，由此在不同的RDD之间建立血缘关系。因此RDD是天生具有高容错机制的特殊集合，当一个RDD失效的时候，只需要通过重新计算上游的父RDD来重新生成丢失的RDD数据，而不需要通过数据冗余的方式实现容错。
    • 不可变性：一旦创建，RDD的内容就不能被修改。这种不可变性有助于实现数据的容错性和并行性。
    • 可分区性：RDD可以将数据集划分为多个分区，每个分区可以独立地进行操作，从而实现并行处理。分区数决定了数据如何被分配到集群中的计算节点，合适的分区数可以提高计算效率和资源利用率。

二、操作与转换

RDD操作与转换

  1. 创建RDD：

    • 可以从已存在的集合（如列表或数组）创建RDD。
    • 可以从外部数据源（如HDFS、本地文件系统、Hive表等）读取数据创建RDD。
    • 可以使用已存在的RDD来创建新的RDD，通过对现有RDD进行转换操作。

  2. RDD转换(Transformations)：

    • 转换操作用于从一个RDD生成新的RDD，通常是通过映射、过滤、合并等方式进行数据转换。常见的转换操作包括map、filter、flatMap、reduceByKey等。
    • 转换操作是惰性的，不会立即执行计算，而是等到行动操作被触发时才执行。

  3. RDD行动(Actions)：

    • 行动操作用于触发实际的计算，将RDD的结果返回到驱动程序或保存到外部存储系统。常见的行动操作包括collect、count、saveAsTextFile等。
    • 只有当行动操作被触发时，Spark才会根据依赖关系图计算RDD的结果。

三、存储级别与持久化

  1. 存储级别：RDD的存储级别决定了数据在内存和磁盘之间的存储方式。常见的存储级别包括MEMORY_ONLY（仅在内存中存储）、MEMORY_AND_DISK（在内存中存储，不够时写入磁盘）、DISK_ONLY（仅在磁盘中存储）等。
  2. 持久化：可以使用cache或persist方法将RDD存储在内存中，以供多次计算使用。持久化可以提高数据处理的效率，减少重复计算的时间。

四、依赖关系与容错机制

  1. 依赖关系：RDD之间的转换操作会创建依赖关系，这些依赖关系决定了数据如何在整个集群中流动。依赖关系分为窄依赖和宽依赖两种。
    • 窄依赖：子RDD的每个分区依赖于父RDD的一个分区。
    • 宽依赖：子RDD的每个分区可能依赖于父RDD的所有分区，这通常需要进行shuffle操作。
  2. 容错机制：RDD的容错机制基于其血缘信息和不可变性。当一个RDD的某个分区的数据计算失败时，Spark可以使用原始数据和转换操作重新计算该分区，从而实现容错。

五、优化与性能调优

  1. 合理使用缓存：通过缓存常用的RDD，可以减少重复计算的时间，提高数据处理的效率。
  2. 选择合适的分区器：根据数据的特征和计算任务的需求，选择合适的分区器可以优化数据的存储和计算过程。
  3. 调整分区数量：根据集群的配置和计算任务的需求，调整RDD的分区数量可以提高计算效率和资源利用率。

综上所述，RDD是Spark中最重要的抽象之一，它为分布式数据处理提供了一个强大而灵活的模型。通过理解和使用RDD的特性、操作、存储级别、依赖关系以及优化方法，可以构建高效的数据处理流程，并充分利用Spark集群的计算资源。

常见操作

以下是RDD（弹性分布式数据集）的操作及其说明的表格形式展示：

RDD操作说明示例
创建操作
sc.parallelize从本地集合创建RDDval rdd = sc.parallelize(1 to 10)
sc.textFile从外部文件创建RDDval rdd = sc.textFile(“hdfs://…”)
转换操作（Transformation）返回一个新的RDD
map对RDD中的每个元素应用一个函数val mappedRdd = rdd.map(x => x * 2)
filter过滤RDD中的元素，返回满足条件的元素val filteredRdd = rdd.filter(_ > 5)
flatMap类似于map，但每个输入元素可以映射到0或多个输出元素val flatMappedRdd = rdd.flatMap(x => 1 to x)
mapPartitions对RDD的每个分区应用一个函数val mapPartitionsRdd = rdd.mapPartitions(iter => iter.map(_ * 2))
mapPartitionsWithIndex对RDD的每个分区及其索引应用一个函数val indexedRdd = rdd.mapPartitionsWithIndex((index, iter) => iter.map(x => (index, x)))
reduceByKey对键值对RDD中相同键的值进行归约val reducedRdd = rdd.reduceByKey(_ + _)
groupByKey对键值对RDD中相同键的值进行分组val groupedRdd = rdd.groupByKey()
sortByKey对键值对RDD的键进行排序val sortedRdd = rdd.sortByKey()
join对两个键值对RDD中相同键的值进行内连接val joinedRdd = rdd1.join(rdd2)
cogroup对两个键值对RDD中相同键的值进行分组，并返回每个键对应的两个值集合val cogroupedRdd = rdd1.cogroup(rdd2)
行动操作（Action）向驱动程序返回结果或写入外部系统
collect将RDD的所有元素收集到驱动程序中val collected = rdd.collect()
count返回RDD中元素的个数val count = rdd.count()
take返回RDD中的前n个元素val taken = rdd.take(5)
saveAsTextFile将RDD的内容保存到文本文件中rdd.saveAsTextFile(“hdfs://…”)
foreach对RDD中的每个元素应用一个函数（通常用于副作用）rdd.foreach(println)

请注意，以上表格仅列出了RDD的一些常见操作，并非全部。RDD的操作非常丰富，可以根据具体需求选择合适的操作来处理数据。同时，RDD的操作具有惰性特性，即转换操作不会立即执行，而是等到行动操作被触发时才执行。这种机制有助于优化计算过程，提高性能。

支持的数据格式

Apache Spark 的 Resilient Distributed Datasets (RDDs) 支持多种数据格式的读取。以下是一些常见的数据格式及其对应的 Java 代码样例：
spark支持的数据格式

1.文本文件 (Text Files)

import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.SparkConf;

public class TextFileRDD {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("TextFileRDD").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 读取文本文件
        JavaRDD<String> textFile = sc.textFile("path/to/textfile.txt");

        // 打印前10行
        textFile.take(10).forEach(System.out::println);

        sc.stop();
    }
}

2. CSV 文件

Spark 官方没有直接提供 CSV 文件的读取功能，但你可以使用 spark-csv 库（Spark 2.0 及以前）或者 DataFrameReader（Spark 2.0 及以后）来读取 CSV 文件。

使用 DataFrameReader 读取 CSV 文件：

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

public class CSVFileRDD {
    public static void main(String[] args) {
        SparkSession spark = SparkSession.builder()
                .appName("CSVFileRDD")
                .master("local")
                .getOrCreate();

        // 读取CSV文件
        Dataset<Row> csvDF = spark.read().option("header", "true").csv("path/to/csvfile.csv");

        // 显示内容
        csvDF.show();

        spark.stop();
    }
}

3. JSON 文件

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

public class JSONFileRDD {
    public static void main(String[] args) {
        SparkSession spark = SparkSession.builder()
                .appName("JSONFileRDD")
                .master("local")
                .getOrCreate();

        // 读取JSON文件
        Dataset<Row> jsonDF = spark.read().json("path/to/jsonfile.json");

        // 显示内容
        jsonDF.show();

        spark.stop();
    }
}

4. Parquet 文件

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

public class ParquetFileRDD {
    public static void main(String[] args) {
        SparkSession spark = SparkSession.builder()
                .appName("ParquetFileRDD")
                .master("local")
                .getOrCreate();

        // 读取Parquet文件
        Dataset<Row> parquetDF = spark.read().parquet("path/to/parquetfile.parquet");

        // 显示内容
        parquetDF.show();

        spark.stop();
    }
}

5. Sequence Files

import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.SparkConf;
import scala.Tuple2;

public class SequenceFileRDD {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("SequenceFileRDD").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 读取SequenceFile
        JavaPairRDD<IntWritable, Text> sequenceFile = sc.sequenceFile("path/to/sequencefile", IntWritable.class, Text.class);

        // 打印键值对
        sequenceFile.collect().forEach(tuple -> System.out.println(tuple._1() + " : " + tuple._2()));

        sc.stop();
    }
}

6.Hadoop文件读取

在Apache Spark中读取Hadoop数据通常涉及访问存储在Hadoop分布式文件系统（HDFS）上的数据，或者通过Hadoop的输入格式（InputFormat）读取数据。以下是一些使用Spark读取Hadoop数据的Java代码示例：

A. 读取HDFS上的文本文件

这是最简单的情况，因为Spark可以直接通过textFile方法读取HDFS上的文本文件，就像读取本地文件系统上的文件一样。

import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.SparkConf;

public class HDFSTextFileReader {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("HDFSTextFileReader").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 假设HDFS上的文件路径为hdfs://namenode:port/path/to/textfile.txt
        String hdfsFilePath = "hdfs://namenode:port/path/to/textfile.txt";
        JavaRDD<String> textFile = sc.textFile(hdfsFilePath);

        // 处理数据，例如打印前10行
        textFile.take(10).forEach(System.out::println);

        sc.stop();
    }
}
B. 使用Hadoop的InputFormat读取数据

对于存储在Hadoop中的非文本数据，或者需要更复杂的数据解析，你可以使用Hadoop的InputFormat。这通常涉及创建一个Hadoop配置对象，并设置必要的属性，然后使用Spark的newAPIHadoopFile或newAPIHadoopRDD方法。

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.SparkConf;
import scala.Tuple2;

public class HadoopInputFormatReader {
    public static void main(String[] args) throws Exception {
        SparkConf conf = new SparkConf().setAppName("HadoopInputFormatReader").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 创建Hadoop配置对象
        Configuration hadoopConf = new Configuration();
        Job job = Job.getInstance(hadoopConf, "Read from Hadoop InputFormat");
        job.setJarByClass(HadoopInputFormatReader.class);

        // 设置输入路径
        FileInputFormat.addInputPath(job, new Path("hdfs://namenode:port/path/to/hadoopfile"));

        // 使用newAPIHadoopRDD读取数据
        JavaPairRDD<LongWritable, Text> hadoopRDD = sc.newAPIHadoopRDD(
                hadoopConf,
                job.getInputFormatClass(),
                LongWritable.class,
                Text.class
        );

        // 处理数据，例如打印键值对
        hadoopRDD.collect().forEach(tuple -> System.out.println(tuple._1() + " : " + tuple._2().toString()));

        sc.stop();
    }
}

在这个例子中，我们假设Hadoop文件是使用LongWritable作为键（通常是偏移量）和Text作为值（行内容）存储的。你需要根据你的Hadoop文件格式调整键和值的类型。

注意事项
  1. Hadoop配置：确保你的Hadoop配置（如core-site.xml和hdfs-site.xml）在Spark的classpath中，或者通过编程方式设置必要的配置属性。
  2. 依赖项：在你的项目中包含Hadoop和Spark的依赖项。
  3. HDFS访问：确保Spark能够访问HDFS。这通常意味着Spark集群的节点需要配置为能够访问HDFS的namenode和datanode。
  4. 性能考虑：对于大规模数据集，避免使用collect()方法将数据从集群拉取到驱动程序。相反，使用转换和行动操作在集群上处理数据。
    这些示例展示了如何使用 Java 代码在 Spark 中读取不同类型的文件。根据具体需求，你可能需要调整路径、选项和其他参数。

一个完整代码示例

以下是一个使用Java编写的基本RDD（弹性分布式数据集）代码示例，该示例展示了如何在Apache Spark中创建RDD、执行转换操作以及行动操作。

首先，请确保您已经设置好Spark环境，并导入了必要的Spark库。

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import java.util.Arrays;
import java.util.List;

public class RDDExample {
    public static void main(String[] args) {
        // 配置Spark
        SparkConf conf = new SparkConf().setAppName("RDD Example").setMaster("local");
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 从本地集合创建RDD
        List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
        JavaRDD<Integer> rdd = sc.parallelize(data);

        // 转换操作：将每个元素乘以2
        JavaRDD<Integer> transformedRDD = rdd.map(x -> x * 2);

        // 行动操作：收集RDD中的所有元素并打印
        List<Integer> collectedData = transformedRDD.collect();
        for (Integer num : collectedData) {
            System.out.println(num);
        }

        // 关闭Spark上下文
        sc.close();
    }
}

在这个示例中，我们：

  1. 配置了Spark环境，并创建了一个JavaSparkContext对象，它是与Spark集群交互的主要入口点。
  2. 使用sc.parallelize方法从本地集合创建了一个RDD。
  3. 对RDD执行了一个转换操作，使用map函数将RDD中的每个元素乘以2。
  4. 使用collect行动操作将转换后的RDD收集到驱动程序中，并打印出结果。
  5. 最后，关闭了Spark上下文以释放资源。

请注意，setMaster("local")配置意味着Spark将在本地模式下运行，仅使用一个线程。如果您想在集群上运行此代码，请将setMaster的值更改为集群管理器（如YARN、Mesos或Spark Standalone）的URL。

此外，由于collect操作会将数据从集群节点收集到驱动程序中，因此在处理大量数据时可能会导致内存溢出。在实际应用中，应谨慎使用此类行动操作，并考虑使用其他行动操作（如saveAsTextFile）将结果写入外部存储系统。

RDD、Datasets和DataFrame的对比

以下是RDD、Datasets和DataFrame的对比表格，展示了它们之间的主要区别和特性：

特性/组件RDDDataFrameDatasets
基础弹性分布式数据集，Spark最基础的数据结构分布式数据集合，带有Schema元信息的二维表格结构化API的基本类型，基于DataFrame的扩展
数据格式可处理结构化或非结构化数据仅使用结构化和半结构化数据可处理结构化或非结构化数据
Schema信息需要手动定义可以根据数据自动发现可以自动发现文件的Schema信息
类型安全编译时类型安全性较弱，主要在运行时检测属性错误提供编译时类型安全性提供编译时类型安全性，且支持强类型、面向对象编程的接口
序列化使用Java序列化，开销较大使用off-heap内存减少开销，动态生成字节码使用Spark内部的Tungsten二进制格式进行序列化，无需垃圾回收
优化无内置优化引擎，不能使用Spark高级优化器使用Catalyst优化器进行查询优化使用优化器优化执行计划
API支持提供Java、Scala、Python和R语言的API提供Java、Scala、Python和R语言的APIScala和Java支持较完善，Python和R语言的API在开发中
操作便捷性底层操作，需要手动管理Schema和分区高级抽象，易于使用，支持SQL操作兼具DataFrame的便捷性和RDD的功能性
适用场景需要对数据集进行底层转换和操作时需要高级抽象和便捷操作时，如探索性分析和汇总统计需要类型安全和自定义结构时，如处理复杂数据类型和转换

这个表格概括了RDD、DataFrame和Datasets在Spark中的主要特性和区别。RDD提供了最底层的数据抽象，适用于需要细粒度控制和自定义操作的场景。DataFrame则提供了更高层次的抽象，易于使用且支持SQL操作，适用于数据分析和探索性场景。Datasets则结合了RDD和DataFrame的优点，提供了类型安全和面向对象编程的接口，适用于需要处理复杂数据类型和转换的场景。在选择使用哪个组件时，需要根据具体的应用场景和需求来决定。

问道飞鱼
关注
专栏目录
深入理解RDD弹性分布式数据集
pysense的博客
12-26 1047
文章目录前言1、RDD简介2、创建RDD3、宽依赖和窄依赖4、通过RDD的依赖关系构建DAG计算图5、RDD 持久化6、RDD的checkpointing机制7、Spark分区与RDD分区（待更新） 前言   在前面的博客《深入理解Spark》 深入探讨了Spark架构原理内容，该文提到Stage的划分，为什么要做Stage划分？是为了得到更小的Task计算单元，分发给Executor的线程运行，...
Spark RDD弹性分布式数据集
09-28
RDD（Resilient Distributed Datasets弹性分布式数据集）是一个容错的、并行的数据结构，可以简单的把RDD理解成一个提供了许多操作接口的数据集合，和一般数据集不同的是，其实际数据分布存储于一批机器中（内存或...
【精通Spark系列】弹性分布式数据集RDD快速入门篇
大数据小禅的博客
10-03 2087
本篇文章属于Spark系列文章，专栏将会记录从spark基础到进阶的内容，，内容涉及到Spark的入门集群搭建，核心组件，RDD，算子的使用，底层原理，SparkCore，SparkSQL，SparkStreaming等，
弹性分布式数据集rdd_弹性分布式数据集（RDD）
danpu0978的博客
05-19 260
弹性分布式数据集rdd 在这篇文章中，我将提到RDD论文， 弹性分布式数据集：内存中群集计算的容错抽象 。 如果您没有阅读有关Spark的文章，我强烈建议您从这里阅读： Spark：带有工作集的集群计算 。 RDD抽象 RDD是一种分布式内存抽象，可利用应用程序性能，因为它以容错的方式适用于迭代算法和交互式数据挖掘工具。 其他集群计算框架（如MapReduce和Dryad）缺乏利用分布式内...
Spark RDD（弹性分布式数据集）
weixin_47243236的博客
12-09 876
1. RDD 1.1 RDD 是什么 RDD（Resilient Distributed Dataset）：弹性分布式数据集，是 Spark 对数据集的抽象，代表一个只读、不可变、可分区、其中元素可进行并行计算的集合，并且是可跨越集群节点进行并行操作的有容错机制的集合。 RDD 是通过 Hadoop 文件系统（HDFS）中文件或者驱动程序中现有的 Scala 集合开始，然后对其进行转换来创建的。 1.2 RDD 特性 A list of partitions RDD 是一个包含多个分区的列表
Spark 核心数据结构：弹性分布式数据集 RDD
我乐了的博客
02-15 797
RDD 是 Spark 最核心的数据结构，RDD（Resilient Distributed Dataset）全称为弹性分布式数据集，是 Spark 对数据的核心抽象，也是最关键的抽象，它实质上是一组分布式的 JVM 不可变对象集合，不可变决定了它是只读的，所以 RDD 在经过变换产生新的 RDD 时，（如下图中 A-B），原有 RDD 不会改变。通过第三方库的支持，Spark 几乎能够读取所有的数据源，例如 Elasticsearch，所以你如果要尝试的话，尽量选用 Maven 来管理依赖。
Spark中的弹性分布式数据集RDD
Liang_DJ的博客
07-16 557
Spark中的最基本的数据抽象就是RDD（Resilient Distributed Dataset, 弹性分布式数据集）
大数据开发之Spark（RDD弹性分布式数据集）
key_honghao的博客
01-23 1420
1、hashpartitioner源码解读case _ =>false2、自定义分区器要实现自定义分区器，需要继承org.apache.spark.partitioner类，并实现下面三个方法。1）numpartitions：int：返回创建出来的分区数2）getpartition(key:any)：int：返回给定键的分区编号（0到numpartitions-1）3）equals()：java判断相等性的标准方法。
Spark—弹性分布式数据集RDD
shine302的博客
04-18 516
1）RDD的起源Hadoop的数据存储模式为：从物理存储上加载数据、操作数据、然后写入物理存储设备。缺点1：运行迭代式算法很慢、无法进行交互式的数据挖掘解决方法：数据存储在内存中缺点2：实现数据集的容错性（数据恢复）代价高（庞大的数据集网络传输）解决方法：高度受限的共享内存(思想如下)2）RDD定义RDD是分布式内存的一个抽象概念，是一种高度受限的共享内存模型，即RDD是只读的记录分区的集合，能够...
SparkRDD之弹性分布式数据集RDD
qq_40208605的博客
08-14 614
2.RDD概述2.1什么是RDD RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象，它代表一个不可变、可分区、里面的元素可并行计算的集合。RDD具有数据流模型的特点：自动容错、位置感知性调度和可伸缩性。RDD允许用户在执行多个查询时显式地将数据缓存在内存中，后续的查询能够重用这些数据，这极大地提升了查询速度。 Datase...
RDD（弹性分布式数据集）
fighting
03-24 5085
1、什么是RDD RDD（分布式弹性数据集）是对分布式计算的抽象，代表要处理的数据，一个数据集,RDD是只读分区的集合。数据被分片，分成若干个数据分片，存储到不同的节点中，可以被并行的操作，所以叫分布式数据集。计算时优先考虑放于内存中，如果放不下把一部分放在磁盘上保存。 RDD（分布式弹性数据集）是整个Spark抽象的基石，是基于工作集的应用抽象。Spark的各个子框架，Spark SQL、S...
【分布式微服务云原生】掌握 Redis Cluster架构解析、动态扩展原理以及哈希槽分片算法
最新发布
Dylaniou的博客
10-06 798
Redis Cluster 提供了一种有效的数据分片和高可用性解决方案。它通过在多个节点上分布数据来提高性能，并能够在主节点故障时自动进行故障转移。然而，它也有一些限制，开发者需要根据应用场景和需求来决定是否使用 Cluster 模式。
利用redis实现分布式定时任务
weixin_42759398的博客
09-29 452
如果是微服务，两个服务都有定时，那么就出问题了，但是上分布式定时任务框架太麻烦怎么办，那么就用redis加个锁，谁先抢到锁谁执行。但是写起来还要改定时任务代码，贼麻烦，直接用切面 环绕的那种，然后抢到锁执行就行.
河南移动：核心营业系统稳定运行超300天，数据库分布式升级实践｜OceanBase案例
OceanBase分布式数据库的博客
09-29 1031
河南移动基于自研轩辕数据总线替换方案，河南移动在两个月内完成了一套承载 1500 万用户的核心系统，从传统数据库到 OceanBase 的平滑升级，并取得运维效率显著提升、7×24 小时稳定运行的卓越成效。
分布式选举 - Zab 协议选举过程详解
fenglingguitar的专栏
09-29 844
Zookeeper 的选举过程是一个高效且可靠的分布式协调机制，它通过投票选举机制确保 Leader 节点的快速切换与系统的一致性。基于Zab 协议的设计，使得 Zookeeper 能够在分布式系统中发挥出色的性能和稳定性。在实际的分布式应用中，了解 Zookeeper 的选举过程可以帮助我们更好地设计高可用的分布式系统，并对系统故障时的行为有更清晰的预期。
通信工程学习：什么是DQDB分布式队列双总线
limengshi138392的博客
10-01 952
通信工程学习：什么是DQDB分布式队列双总线
【分布式微服务云原生】掌握分布式缓存：Redis与Memcached的深入解析与实战指南
Dylaniou的博客
10-03 1447
Redis和Memcached都是强大的分布式缓存解决方案，但它们在功能、持久化、数据结构支持等方面有所不同。Redis提供了更丰富的数据结构和持久化机制，而Memcached则以其简单性和高性能著称。在选择分布式缓存时，需要根据具体的业务需求和场景进行选择。
【分布式微服务云原生】gRPC vs RPC：深入探索远程过程调用的现代与经典
Dylaniou的博客
10-01 1288
在构建分布式系统时，远程过程调用（RPC）是一种常用的技术，它允许程序像调用本地函数一样调用远程服务器上的函数。gRPC，作为RPC的一种现代实现，以其高性能和丰富的特性受到开发者的青睐
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

问道飞鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值