Spark 简介

victorchutian 发布于 2025-08-14 收录于类别 Spark

当数据量超过单机内存和 CPU 的处理能力时，很多熟悉的批处理程序会遇到同一个问题：逻辑不难，但很难高效地拆到多台机器上运行。Spark 要解决的正是这件事。它把分布式存储上的数据抽象成可并行操作的数据集，把用户代码转换成可以在集群中调度的任务，同时提供 SQL、流处理、机器学习等统一 API。

Rust Future 实现原理

victorchutian 发布于 2025-04-30 收录于类别 Rust

Rust 既支持了基于系统线程的多线程编程模型，也支持了基于async/await的异步编程模型。Rust 的async编程有有以下特性:

Future 在 Rust 中是惰性的
Async 在 Rust 中使用开销是零
Rust 没有内置异步调用所必需的运行时，但是社区生态中已经提供了非常优异的运行时实现，例如 tokio和async-std
运行时同时支持单线程和多线程

发明服务特征

victorchutian 发布于 2025-04-30 收录于类别 Rust

Tower是一个模块化和可重用组件库，用于构建健壮的网络客户端和服务器。其核心是Service特征。Service是一个异步函数，它接受请求并产生响应。然而，其设计的某些方面可能并不明显。与其解释目前Tower中存在的Service特征，让我们通过想象如果你从头开始，你会如何发明它来看看Service背后的动机。

使用 vscode 开发 Rust

victorchutian 发布于 2025-04-19 收录于类别 Rust

本文将介绍如果基于 vscode 搭建 Rust 开发环境。

Rust Struct 字段自引用问题

victorchutian 发布于 2025-04-11 收录于类别 Rust

先来看一段 Java 代码，Application中有version和 logger。logger 依赖了 Version。

public class Application
{
    public Version version;
    public Logger logger;
    public Application() {
        version = new Version(1);
        logger =  new Logger(version);
    }

    public static void main(String[] args)
    {
        Application application = new Application();
        application.logger.log("Hello World!");
        // console output:
        // [version 1] Hello World!
    }
    class Version {
        public int ver;
        public Version (int ver){
            this.ver = ver;
        }
        public String toString() {
            return String.format("version %d",ver);
        }
    }
    class Logger {
        public Version version;
        public Logger (Version version){
            this.version = version;
        }
        void log(String msg) {
            System.out.println(String.format("[%s] %s",version,msg));
        }
    }
}

那么问题来了，如何在 Rust 中实现相同的代码？

Rust-生命周期

victorchutian 发布于 2025-04-01 收录于类别 Rust

生命周期，简而言之就是引用的有效作用域。在大多数时候，我们无需手动的声明生命周期，因为编译器可以自动进行推导。当多个生命周期存在，且编译器无法推导出某个引用的生命周期时，就需要我们手动标明生命周期。

悬垂指针和生命周期

生命周期的主要作用是避免悬垂引用，它会导致程序引用了本不该引用的数据：

{
    let r;
    {
        let x = 5;
        r = &x;
    }    // ^^ borrowed value does not live long enough
    println!("r: {}", r);
}

此处 r 就是一个悬垂指针，它引用了提前被释放的变量 x。

借用检查

为了保证 Rust 的所有权和借用的正确性，Rust 使用了一个借用检查器(Borrow checker)，来检查我们程序的借用正确性：

{
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {}", r); //          |
}                         // ---------+

r 变量被赋予了生命周期 ‘a，x 被赋予了生命周期 ‘b，从图示上可以明显看出生命周期 ‘b 比 ‘a 小很多。在编译期，Rust 会比较两个变量的生命周期，结果发现 r 明明拥有生命周期 ‘a，但是却引用了一个小得多的生命周期 ‘b，在这种情况下，编译器会认为我们的程序存在风险，因此拒绝运行。如果想要编译通过，也很简单，只要 ‘b 比 ‘a 大就好。总之，x 变量只要比 r 活得久，那么 r 就能随意引用 x 且不会存在危险：

{
    let x = 5;            // ----------+-- 'b
                          //           |
    let r = &x;           // --+-- 'a  |
                          //   |       |
    println!("r: {}", r); //   |       |
                          // --+       |
}                         // ----------+

TCP-超时重传

victorchutian 发布于 2025-03-28 收录于类别 Network

TCP协议是一种面向连接的有状态网络协议。对于发送的每个数据包，一旦TCP堆栈收到特定数据包的ACK，它就认为它已成功传递。

TCP使用指数退避超时重传一个未确认的数据包，最多tcp_retries2时间（默认为15），每次重传超时在TCP_RTO_MIN（200毫秒）和TCP_RTO_MAX（120秒）之间。一旦第15次重试到期（默认情况下），TCP堆栈将通知上面的层（即应用程序）断开连接。

系统性能分析-CPU耗时定位

victorchutian 发布于 2025-03-11 收录于类别 Computer 和系列 Linux 性能分析

上篇博客介绍了 CPU异常分析的工具和方法。本文将介绍如何定位 CPU 耗时。

Rust-特征

victorchutian 发布于 2025-03-11 收录于类别 Rust

如果不同的类型具有相同的行为，那么我们就可以定义一个特征，然后为这些类型实现该特征。定义特征是把一些方法组合在一起，目的是定义一个实现某些目标所必需的行为的集合。

例如，我们现在有文章 Post 和微博 Weibo 两种内容载体，而我们想对相应的内容进行总结，也就是无论是文章内容，还是微博内容，都可以在某个时间点进行总结，那么总结这个行为就是共享的，因此可以用特征来定义：

pub trait Summary {
    fn summarize(&self) -> String;
}

特征只定义行为看起来是什么样的，而不定义行为具体是怎么样的。因此我们需要为实现特征的类型，定义行为具体是怎么样的。

pub struct Post {
    pub title: String,
    pub author: String,
    pub content: String,
}
impl Summary for Post {
    fn summarize(&self) -> String {
        format!("文章{}, 作者是{}", self.title, self.author)
    }
}

Rust 智能指针简介

victorchutian 发布于 2025-03-07 收录于类别 Rust

指针是一个包含了内存地址的变量，该内存地址引用或者指向了另外的数据。

在 Rust 中，最常见的指针类型是引用，引用通过 & 符号表示。不同于其它语言，引用在 Rust 中被赋予了更深层次的含义，那就是：借用其它变量的值。引用本身很简单，除了指向某个值外并没有其它的功能，也不会造成性能上的额外损耗，因此是 Rust 中使用最多的指针类型。

而智能指针则不然，它虽然也号称指针，但是它是一个复杂的家伙：通过比引用更复杂的数据结构，包含比引用更多的信息，例如元数据，当前长度，最大可用长度等。智能指针往往是基于结构体实现，它与我们自定义的结构体最大的区别在于它实现了 Deref 和 Drop 特征：

Deref 可以让智能指针像引用那样工作，这样你就可以写出同时支持智能指针和引用的代码，例如 *T
Drop 允许你指定智能指针超出作用域后自动执行的代码，例如做一些数据清除等收尾工作

而 Box 指针是最简单的智能指针。本文将介绍 Box 指针以及 Deref 和 Drop 特征。

Java 操作HDFS小结

victorchutian 发布于 2025-03-05 收录于类别 Java

本文总结了如何使用 Java 客户端操作 HDFS，以及一些注意点。

系统性能分析-CPU-异常分析

victorchutian 发布于 2024-09-18 收录于类别 Computer 和系列 Linux 性能分析

本文记录一些分析 CPU 性能问题的工具&方法。

varint编码

victorchutian 发布于 2024-06-18 收录于类别 Storage

Varint是一种使用一个或多个字节序列化整数的方法，会把整数编码为变长字节。对于32位整型的4个字节数据经过Varint编码后需要1~5个字节，小的数字使用1个byte，大的数字使用5个bytes。64位整型数据编码后占用1~10个字节。

在实际场景中小数字的使用率远远多于大数字，因此通过Varint编码对于大部分场景都可以起到很好的压缩效果。

异步编程模型:Promises vs Futures

victorchutian 发布于 2024-06-17 收录于类别 Architecture

本文将介绍两种异步编程模型: Promise 和 Future。在计算机科学中，future、promise，是在某些并发编程语言中，指称用于同步程序执行的一种构造。由于某些计算尚未结束，故而需要一个对象来代理这个未知的结果。Future 和 Promise 的设计理念整体上非常相似，但是在不同的语言和框架实现中又存在一定的区别，对此，这里我们基于最广泛的定义进行介绍。

Future：表示异步任务的返回值，表示一个未来值(只读)的占位符，即未来值的消费者。
Promise：表示异步任务的执行过程，表示一个可写的单赋值容器，即未来值的生产者。

在同时包含 Future 和 Promise 的实现中，一般 Promise 对象会有一个关联的 Future 对象。当 Promise 创建时，Future 对象会自动实例化。当异步任务执行完毕，Promise 在内部设置结果，从而将值绑定至 Future 的占位符中。Future 则提供读取方法。将异步操作分成 Future 和 Promise 两个部分的主要原因是为了实现读写分离，对外部调用者只读，对内部实现者只写。