inasayang's blog

Go | First Response Pattern

xiayangzzw@gmail.com (inasayang) — Thu, 07 Aug 2025 00:00:00 Z

// Avoid timeout - Replicate servers and use first response
type Result string
type Search func(query string) Result

func fakeSearch(kind string) Search {
	return func(query string) Result {
		time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
		return Result(fmt.Sprintf("%s result for %q", kind, query))
	}
}

func First(query string, replicas ...Search) Result {
	c := make(chan Result)
	searchReplica := func(i int) { c <- replicas[i](query) }
	for i := range replicas {
		go searchReplica(i)
	}
	return <-c
}

func main() {
	start := time.Now()
	result := First("golang",
		fakeSearch("replica1"), 
		fakeSearch("replica2"),
		fakeSearch("replica3"))
	elapsed := time.Since(start)
	fmt.Println(result)
	fmt.Printf("%.3fms\n", float64(elapsed.Nanoseconds())/1e6)
}

这是 Go 并发经典实践之一：“用副本竞速的方式避免超时，返回最早的可用结果”——常见于高可用分布式系统的请求快速返回（比如多个搜索副本、微服务副本集请谁先响应）。

# 主要思想

业务背景：你有好几个“备用服务器/副本/搜索实现”，哪个响应最快用哪个，“慢的都不用等”，避免整个请求因单点慢或偶发延迟变慢。
这是现实世界中 Google、Amazon 等公司搜索引擎“边缘副本”、“异地容灾高可用”大量使用的技术方案。

# 现实应用场景

微服务多活：多个服务副本响应同一请求，优先拿到第一个并快速返回，极大降低99.99延迟。
CDN/边缘计算：拉取数据时向多节点并发请求，客户端只拿第一个响应的内容。
多家供应商比价/辅助搜索聚合：哪个接口快就显示谁的内容。

# 使用context控制goroutine leak

这个简单写法确实会导致 goroutine 泄露（goroutine leak）的问题。

你发起了多个副本 goroutine，每个都会做完自己的“搜索”然后把结果写入同一个 channel c。
但 First 只从 channel 取第一个结果：return <-c
其它 goroutine 后续写入 channel 时，如果没人读，它们会永远阻塞在 c <- ... 这一行上——此时这些 goroutine 无法退出，即内存泄露。

func First(query string, replicas ...Search) Result {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	c := make(chan Result)
	searchReplica := func(i int) {
		select {
		case c <- replicas[i](query):
		case <-ctx.Done():
			return
		}
	}
	for i := range replicas {
		go searchReplica(i)
	}
	result := <-c
	cancel() // 让其他 goroutine 自动退出
	return result
}

主流程一旦拿到第一个结果，cancel() 会通知其他所有 goroutine 退出。

复杂情况下可配合 context、WaitGroup 做到无资源泄露。

https://www.concurrency.rocks/

C | _Generic泛型选择

xiayangzzw@gmail.com (inasayang) — Fri, 25 Jul 2025 00:00:00 Z

Notion链接

_Generic 在 C 语言中被称为泛型选择（Generic Selection）或类型泛型表达式。这是 C11 标准引入的特性。

主要用于类型感知的宏编程，实现类似函数重载的效果
在编译时处理，编译器会直接替换为对应的表达式
基于类型进行选择
是一个表达式，会被替换为某个值

示例：

// 编译时根据类型选择
int i = 10;
char *result = _Generic(i,
    int: "integer",
    float: "float",
    default: "other"
);
// 编译后直接变成：char *result = "integer";

_Generic 是一个表达式，不是语句，错误示例：

// ❌ 错误！不能写多行代码
int i = 10;
char *result = _Generic(i,
    int: {
        printf("It's an integer\\n");  // 编译错误
        return "integer";
    },
    float: "float",
    default: "other"
);

## 多行逻辑解决办法

# 1. 使用函数调用

char* handle_int() {
    printf("Processing integer\n");
    // 可以有复杂逻辑
    return "integer";
}

char* handle_float() {
    printf("Processing float\n");
    return "float";
}

int i = 10;
char *result = _Generic(i,
    int: handle_int(),      // 调用函数
    float: handle_float(),
    default: "other"
);

# 2. 使用逗号运算符

int i = 10;
char *result = _Generic(i,
    int: (printf("It's an integer\n"), "integer"),  // 逗号运算符
    float: (printf("It's a float\n"), "float"),
    default: "other"
);

# 3. 结合条件表达式

int i = 10;
char *result = _Generic(i,
    int: i > 0 ? "positive integer" : "non-positive integer",
    float: "float",
    default: "other"
);

# 4. 如果需要复杂逻辑，建议用宏包装

#define HANDLE_TYPE(x) do { \\
    char *result = _Generic((x), \\
        int: handle_int(), \\
        float: handle_float(), \\
        default: "other" \\
    ); \\
    /* 在这里可以添加更多处理逻辑 */ \\
    printf("Result: %s\n", result); \\
} while(0)

// 使用
int i = 10;
HANDLE_TYPE(i);

## 完整示例

# 示例1：

#include <stdio.h>

#define TYPE_NAME(x) _Generic((x), \
    int: "integer", \
    float: "float", \
    double: "double", \
    char: "character", \
    char*: "string", \
    default: "unknown type" \
)

int main(void)
{
    int num = 100;
    float pi = 3.14159f;
    double e = 2.71828;
    char letter = 'Z';
    char *message = "Hello";
    
    printf("num (%d) is a %s\n", num, TYPE_NAME(num));
    printf("pi (%.2f) is a %s\n", pi, TYPE_NAME(pi));
    printf("e (%.5f) is a %s\n", e, TYPE_NAME(e));
    printf("letter ('%c') is a %s\n", letter, TYPE_NAME(letter));
    printf("message (\"%s\") is a %s\n", message, TYPE_NAME(message));
    
    return 0;
}

输出：

num (100) is a integer
pi (3.14) is a float
e (2.71828) is a double
letter ('Z') is a character
message ("Hello") is a string

# 示例2：

#include <stdio.h>
#include <math.h>

// 为不同类型定义不同的处理函数
int process_int(int x) {
    printf("Processing integer: %d\n", x);
    return x * x;  // 返回平方
}

float process_float(float x) {
    printf("Processing float: %.2f\n", x);
    return sqrtf(x);  // 返回平方根
}

double process_double(double x) {
    printf("Processing double: %.6f\n", x);
    return log(x);  // 返回自然对数
}

char process_char(char x) {
    printf("Processing character: '%c'\n", x);
    return x >= 'a' && x <= 'z' ? x - 32 : x;  // 小写转大写
}

void process_default(void) {
    printf("Processing unsupported type\n");
}

// 使用 _Generic 创建泛型处理宏
#define PROCESS(x) _Generic((x), \
    int:    process_int, \
    float:  process_float, \
    double: process_double, \
    char:   process_char, \
    default: process_default \
)(x)

// 另一个例子：类型泛型的比较函数
#define MAX(a, b) _Generic((a) + (b), \
    int:    ((int)(a) > (int)(b) ? (int)(a) : (int)(b)), \
    float:  ((float)(a) > (float)(b) ? (float)(a) : (float)(b)), \
    double: ((double)(a) > (double)(b) ? (double)(a) : (double)(b)), \
    default: 0 \
)

// 类型泛型的格式化输出
#define PRINT_VALUE(x) _Generic((x), \
    int:    printf("Integer: %d\n", (x)), \
    float:  printf("Float: %.2f\n", (x)), \
    double: printf("Double: %.6f\n", (x)), \
    char:   printf("Character: '%c' (ASCII: %d)\n", (x), (int)(x)), \
    char*:  printf("String: \"%s\"\n", (x)), \
    default: printf("Unknown type\n") \
)

int main(void)
{
    printf("=== 泛型处理函数示例 ===\n");
    
    int i = 5;
    float f = 16.0f;
    double d = 2.718281828;
    char c = 'h';
    
    printf("Original values:\n");
    PRINT_VALUE(i);
    PRINT_VALUE(f);
    PRINT_VALUE(d);
    PRINT_VALUE(c);
    
    printf("\nProcessing results:\n");
    int result_i = PROCESS(i);
    float result_f = PROCESS(f);
    double result_d = PROCESS(d);
    char result_c = PROCESS(c);
    
    printf("\nProcessed values:\n");
    PRINT_VALUE(result_i);
    PRINT_VALUE(result_f);
    PRINT_VALUE(result_d);
    PRINT_VALUE(result_c);
    
    printf("\n=== 泛型最大值函数示例 ===\n");
    
    int max_int = MAX(10, 25);
    float max_float = MAX(3.14f, 2.71f);
    double max_double = MAX(1.234567, 1.234568);
    
    printf("MAX(10, 25) = %d\n", max_int);
    printf("MAX(3.14f, 2.71f) = %.2f\n", max_float);
    printf("MAX(1.234567, 1.234568) = %.6f\n", max_double);
    
    printf("\n=== 混合类型示例 ===\n");
    
    char *str = "Hello World";
    long long big_num = 9876543210LL;
    
    PRINT_VALUE(str);
    PRINT_VALUE(big_num);  // 会触发 default 情况
    
    return 0;
}

输出：

=== 泛型处理函数示例 ===
Original values:
Integer: 5
Float: 16.00
Double: 2.718282
Character: 'h' (ASCII: 104)

Processing results:
Processing integer: 5
Processing float: 16.00
Processing double: 2.718282
Processing character: 'h'

Processed values:
Integer: 25
Float: 4.00
Double: 1.000000
Character: 'H' (ASCII: 72)

=== 泛型最大值函数示例 ===
MAX(10, 25) = 25
MAX(3.14f, 2.71f) = 3.14
MAX(1.234567, 1.234568) = 1.234568

=== 混合类型示例 ===
String: "Hello World"
Unknown type

https://en.cppreference.com/w/c/language/generic.html
Claude Sonnet 4 Thinking

Go | 跨包访问非导出符号

xiayangzzw@gmail.com (inasayang) — Mon, 21 Apr 2025 00:00:00 Z

//go:linkname 是 Go 语言中的一个编译指令（compiler directive），用于在编译期间将一个符号（函数或变量）的名称重命名成另一个符号，达到在不同包之间绕过封装直接访问非导出（unexported）标识符的效果。

需要导入 unsafe 包
函数或变量必须声明

# 使用未导出函数（示例1）：

package mypkg

import _ "unsafe"

//go:linkname privateFunc runtime.internalFunc
func privateFunc()

这里 mypkg 包里的 privateFunc 会被链接为 runtime 包中的非导出函数 internalFunc，调用privateFunc() 就是调用的 runtime.internalFunc()。

# 使用未导出函数（示例2）：

package main

import (
    _ "unsafe"
    _ "github.com/xxx/yyy/zzz"  // 确保包被导入
)

//go:linkname newUUID github.com/xxx/yyy/zzz.newUUID
func newUUID() string

func main() {
    s := newUUID()
    fmt.Println(s)
}

# 使用未导出变量：

package yourpkg

import _ "unsafe"

//go:linkname someValue github.com/xxx/yyy/zzz.someValue
var someValue int

Go | 使用PGO优化编译示例

xiayangzzw@gmail.com (inasayang) — Tue, 15 Apr 2025 00:00:00 Z

PGO (Profile-Guided Optimization) 是一种编译优化技术，通过收集程序的实际运行时数据来指导编译器进行更有针对性的优化。

-pgo file
        specify the file path of a profile for profile-guided optimization (PGO).
        When the special name "auto" is specified, for each main package in the
        build, the go command selects a file named "default.pgo" in the package's
        directory if that file exists, and applies it to the (transitive)
        dependencies of the main package (other packages are not affected).
        Special name "off" turns off PGO. The default is "auto".

这段说明解释了 -pgo 参数的几种用法：

pgo=文件路径 - 指定一个具体的性能分析文件路径用于PGO优化
pgo=auto - 自动模式(默认)，会在每个main包的目录中查找名为"default.pgo"的文件
pgo=off - 明确关闭PGO优化

当使用自动模式时，PGO优化只会应用到main包及其依赖项，而不会影响其他不相关的包。

# 收集性能分析数据

// main.go
package main

import (
    "os"
    "runtime/pprof"
)

func computeIntensive() int {
    result := 0
    for i := 0; i < 10000000; i++ {
        result += i % 10
    }
    return result
}

func main() {
    // 第一次运行时开启性能分析
    if len(os.Args) > 1 && os.Args[1] == "profile" {
        f, _ := os.Create("profile.pprof")
        defer f.Close()
        pprof.StartCPUProfile(f)
        defer pprof.StopCPUProfile()
    }
    
    // 执行计算密集型操作
    result := computeIntensive()
    println("Result:", result)
}

go build -o myapp.exe .
./myapp.exe profile

# 使用收集的分析数据进行优化编译

go build -pgo profile.pprof -o myapp_optimized.exe .

如果有多个pprof文件

# 使用pprof工具合并多个分析文件
go tool pprof -proto cpu1.pprof cpu2.pprof cpu3.pprof > combined.pprof
# 使用合并后的分析文件进行构建
go build -pgo combined.pprof -o myapp_optimized.exe .

# 测试

time ./myapp.exe
time ./myapp_optimized.exe

PGO 优化通常在较大、复杂的应用中效果更显著，特别是有明显热点路径的程序。对于简单程序，优化效果可能不明显，甚至因为优化开销而略微变慢。
PGO 主要适用于计算密集型应用。

Rust | LTO和Thin LTO编译器

xiayangzzw@gmail.com (inasayang) — Tue, 15 Apr 2025 00:00:00 Z

# LTO (Link Time Optimization)

链接时优化是一种编译器优化技术，它在程序的链接阶段而非传统的编译阶段执行代码优化。

## LTO 的工作原理

编译阶段：编译器在编译单个源文件时，不仅生成机器代码，还保存中间表示（IR，Intermediate Representation）到目标文件中
链接阶段：链接器收集所有模块的IR，将它们合并为一个统一的程序表示
全局优化：对整个程序执行优化，基于对所有代码的完整视图

## LTO 的主要优势

跨模块优化：可以进行跨越多个源文件的优化
内联函数：更强大的函数内联能力，包括跨编译单元边界
死代码消除：更有效地移除未使用的代码
更精确的别名分析：改进指针分析和内存访问优化
代码大小减少：通过移除不必要的代码减小二进制大小

## LTO 的缺点

内存消耗大：处理大型程序时需要大量内存
编译时间长：链接过程变得更加复杂和耗时

# Thin LTO (轻量级链接时优化)

Thin LTO 是 LLVM 编译器基础设施引入的 LTO 变种，旨在解决传统 LTO 的性能和扩展性问题。

## Thin LTO 的工作原理

索引生成：每个目标文件都独立生成索引，包含符号和引用信息
并行优化：基于索引信息，将全局优化工作分解成多个可并行执行的任务
模块级优化：在各个模块上并行执行优化，而不是合并所有IR

## Thin LTO 的主要优势

减少内存使用：不需要加载整个程序的IR到内存
并行编译：通过并行化加速编译过程
增量编译支持：更好地支持增量构建
保留大部分传统LTO的优化效果：仍能执行跨模块优化

特性	LTO	Thin LTO
优化效果	最大化	接近LTO但略低
内存使用	高	中等
编译速度	慢	快（尤其在多核系统）
并行度	有限	高
适用场景	最终发布构建	日常开发和发布

# Rust 中使用

[profile.release]
# lto = "off"
# lto = "fat"   
# lto = "thin"

LTO 通常与其他优化标志一起使用。

Linux | 如何在终端使用Progress bar

xiayangzzw@gmail.com (inasayang) — Sat, 24 Aug 2024 00:00:00 Z

原理：使用 ANSI 转义序列来控制光标位置

import time
import sys

def progress_bar(total):
    for i in range(total + 1):
        percent = (i / total) * 100
        # bar = '█' * (i // 2) + '-' * (total // 2 - i // 2)
        bar = '\u2588' * (i // 2) + '-' * (total // 2 - i // 2)
        sys.stdout.write(f'\rProgress: |{bar}| {percent:.2f}%')
        sys.stdout.flush()
        time.sleep(0.1)  # 模拟工作
    print()

progress_bar(100)

\r：这个字符的作用是将光标移动到当前行的开头，而不是换到下一行。这样可以覆盖当前行的内容，实现动态更新。必须写在字符串的最前面，以确保光标移动到当前行的开头。
使用 i // 2 的原因是为了将进度条的长度控制在一个合适的范围内,减少进度条的字符数量，易于阅读

Go | 检测当前系统位数

xiayangzzw@gmail.com (inasayang) — Sat, 09 Mar 2024 00:00:00 Z

# 声明一个常量来表示当前操作系统的位数

const NativeWordBits = 32 << (^uint(0) >> 63) // 64 or 32

^uint(0)：对于无符号整型 uint(0)（其所有位都是0），按位取反操作会产生一个所有位都是1的数字。这个结果的数值上等同于 uint 能表示的最大值。
>> 63：这个操作的结果依赖于 uint 的大小：
- 在64位平台上，uint 类型为64位，^uint(0) 产生一个所有位都为1的64位数字。向右移动63位后，最左边的一位（最高位）会移动到最右边，结果为1（二进制的000…001）
- 在32位平台上，尽管仍然执行相同的操作，但是由于 uint 的大小只有32位，所以这个操作实际上产生的结果是 0，因为32位无法表示一个向右移动了63位的值
32 << (... >> 63)：最终这个表达式将32左移上一步的结果。在32位平台上，由于上一步的结果是 0，32 << 0 保持不变，仍然是 32。这反映了32位系统的字长。在64位平台上，上一步的结果是 1，因此 32 << 1 相当于将32乘以2，结果是 64。这反映了64位系统的字长。

# 检查当前操作系统是32位的还是64位的

const Is64bitOS = ^uint(0) >> 63 != 0 
const Is32bitOS = ^uint(0) >> 32 == 0

Go101

Rust | Clone vs Copy

xiayangzzw@gmail.com (inasayang) — Wed, 13 Sep 2023 00:00:00 Z

## Copy的含义

Copy的全名是std::marker::Copy

std::marker模块里面所有的trait都是特殊的trait

它们是跟编译器密切绑定的，impl这些trait对编译器的行为有重要影响。在编译器眼里，它们与其他的trait不一样。这几个trait内部都没有方法，它们的唯一任务是给类型打一个“标记”，表明它符合某种约定——这些约定会影响编译器的静态检查以及代码生成

那么，Copy这个trait在编译器的眼里代表的是什么意思呢？

简单点总结就是，如果一个类型impl了Copy trait，意味着任何时候，我们都可以通过简单的内存复制（在C语言里按字节复制memcpy）实现该类型的复制，并且不会产生任何内存安全问题。

一旦一个类型实现了Copy trait，那么它在变量绑定、函数参数传递、函数返回值传递等场景下，都是copy语义，而不再是默认的move语义。

最简单的赋值语句x = y来说明move语义和copy语义的根本区别

move语义是“剪切、粘贴”操作，变量y把所有权递交给了x之后，y就彻底失效了，后面继续使用y就会出编译错误
copy语义是“复制、粘贴”操作，变量y把所有权递交给了x之后，它自己还留了一个副本，在这句赋值语句之后，x和y依然都可以继续使用

在Rust里，move语义和copy语义具体执行的操作，是不允许由程序员自定义的。

move语义或者copy语义都是执行的memcpy，无法更改，这个过程中绝对不存在其他副作用。

如果考虑后端优化，在许多情况下，不必要的内存复制实际上已经彻底优化掉了，不必担心执行效率的问题。没有必要每次都把move或者copy操作与具体的汇编代码联系起来，因为场景不同，优化结果不同，生成的代码也是不同的。只需记住的是语义。

## Copy的实现条件

并不是所有的类型都可以实现Copy trait。Rust规定，对于自定义类型，只有所有成员都实现了Copy trait，这个类型才有资格实现Copy trait。

常见的数字类型、bool类型、共享借用指针&，都是具有Copy属性的类型
Box、Vec、可写借用指针&mut等类型都是不具备Copy属性的类型
对于数组类型，如果内部的元素类型是Copy，那么这个数组也是Copy类型
对于元组tuple类型，如果每一个元素都是Copy类型，那么这个tuple也是Copy类型
struct和enum类型不会自动实现Copy trait。只有当struct和enum内部的每个元素都是Copy类型时，编译器才允许我们针对此类型实现Copy trait
```
    struct T(i32);
    fn main() {
        let t1 = T(1);
        let t2 = t1;
        println! ("{} {}", t1.0, t2.0);
    }
```
编译错误。原因是在let t2 = t1；这条语句中执行的是move语义。但是可以手动为它impl Copy trait，这样它就具备了copy语义

Rust中只有POD（C++语言中的Plain Old Data）类型才有资格实现Copy trait。

在Rust中，如果一个类型只包含POD数据类型的成员，并且没有自定义析构函数，那它就是POD类型。

比如：整数、浮点数、只包含POD类型的数组等，都属于POD类型；而Box String Vec等不能按字节复制的类型，都不属于POD类型。

并不是所有满足POD的类型都应该实现Copy trait，是否实现Copy取决于业务需求。

## Clone的含义

Clone的全名是std::clone::Clone

    pub trait Clone : Sized {
        fn clone(&self) -> Self;
        fn clone_from(&mut self, source: &Self) {
            ＊self = source.clone()
        }
    }

两个关联方法，分别是clone_from和clone

clone_from是有默认实现的，依赖于clone方法的实现
clone方法没有默认实现，需要手动实现

clone方法一般用于“基于语义的复制”操作。所以，跟具体类型的作用息息相关。比如，对于Box类型，clone执行的是“深复制”；而对于Rc类型，clone做的事情就是把引用计数值加1。

虽然Rust中的clone方法一般是用来执行复制操作的，但是如果在自定义的clone函数中做点别的什么工作，编译器也没办法禁止。可以根据需要在clone函数中编写任意的逻辑。

对于实现了copy的类型，它的clone方法应该跟copy语义相容，等同于按字节复制

## 自动derive

绝大多数情况下，实现Copy Clone这样的trait都是一个重复而无聊的工作。因此，Rust提供了一个attribute，可以利用编译器自动生成这部分代码。示例如下：

    #[derive(Copy, Clone)]
    struct MyStruct(i32);

derive会让编译器自动生成impl Copy和impl Clone这样的代码。自动生成的clone方法，会依次调用每个成员的clone方法。

通过derive方式自动实现Copy和手工实现Copy有微小的区别。当类型具有泛型参数的时候，比如struct MyStruct<T>{}，通过derive自动生成的代码会自动添加一个T:Copy的约束。

## 总结

Copy内部没有方法，Clone内部有两个方法
Copy trait是给编译器用的，告诉编译器这个类型默认采用copy语义，而不是move语义。Clone trait是给程序员用的，我们必须手动调用clone方法，它才能发挥作用
Copy trait不是想实现就能实现的，它对类型是有要求的，有些类型不可能impl Copy。而Clone trait则没有什么前提条件，任何类型都可以实现（unsized类型除外，因为无法使用unsized类型作为返回值）
Copy trait规定了这个类型在执行变量绑定、函数参数传递、函数返回等场景下的操作方式。即这个类型在这种场景下，必然执行的是“简单内存复制”操作，这是由编译器保证的，程序员无法控制。Clone trait里面的clone方法究竟会执行什么操作，则是取决于程序员自己写的逻辑。一般情况下，clone方法应该执行一个“深复制”操作，但这不是强制性的，如果你愿意，在里面启动一个人工智能程序都是有可能的
如果确实不需要Clone trait执行其他自定义操作（绝大多数情况都是这样），编译器提供了一个工具，我们可以在一个类型上添加#[derive(Clone)]，来让编译器自动生成那些重复的代码。编译器自动生成的clone方法非常机械，就是依次调用每个成员的clone方法
Rust语言规定了在T: Copy的情况下，Clone trait代表的含义。即：当某变量t: T符合T: Copy时，它调用t.clone() 方法的含义必须等同于“简单内存复制”。也就是说，clone的行为必须等同于let x = std::ptr::read(&t);，也等同于let x = t;。当T: Copy时，不要在Clone trait里面乱写逻辑。所以，当需要指定一个类型是Copy的时候，最好使用#[derive(Copy,Clone)]方式，避免手动实现Clone导致错误。

深入浅出Rust

Go | 使一个结构体类型不可比较

xiayangzzw@gmail.com (inasayang) — Tue, 08 Aug 2023 00:00:00 Z

可以放置一个非导出的零尺寸的不可比较类型的字段在结构体类型中以使此结构体类型不可比较

结构体

type T struct {
	dummy [0]func()
	AnotherField int
}

使用

var x map[T]int // 编译错误：非法的键值类型

var a, b T
_ = a == b // 编译错误：非法的比较

Go | 0尺寸结构体

xiayangzzw@gmail.com (inasayang) — Mon, 07 Aug 2023 00:00:00 Z

下面四个结构体的尺寸大小各是多少？

type A struct {
	x int64
	y int64
}
type A1 struct {
	x int64
	y int64
	z struct{}
}
type A2 struct {
	z struct{}
	x int64
	y int64
}
type A3 struct {
	x int64
	z struct{}
	y int64
}

答案

A： 16
A1： 24
A2： 16
A3： 16

为什么A1的结构体会不同呢？

一个可寻址的结构值的所有字段都可以被取地址，A1可以被取地址，则z也可以被取地址
如果非零尺寸的结构体值的最后一个字段的尺寸是零，那么取此最后一个字段的地址将会返回一个越出了结构体值分配的内存块的地址（可能指向另一个被分配的内存块）
标准的Go编译器会确保取一个非零尺寸的结构体值的最后一个字段的地址时，绝对不会返回越出分配给此结构体值的内存块的地址
Go标准编译器通过在需要时在结构体最后的零尺寸字段之后填充一些字节来实现这一点
- 具体补多少，需要达到内存对齐即可
如果一个结构体的全部字段的类型都是零尺寸的(因此整个结构体也是零尺寸的)，那么就不需要再填充字节，因为标准编译器会专门处理零尺寸的内存块

Golang101

Rust | Ownership

xiayangzzw@gmail.com (inasayang) — Tue, 20 Jun 2023 00:00:00 Z

# 一段不安全的代码

int* foo() {
    int a;          // 变量a的作用域开始
    a = 100;
    char *c = "xyz";   // 变量c的作用域开始
    return &a;
}                   // 变量a和c的作用域结束

变量 a 和 c 都是局部变量，函数结束后将局部变量 a 的地址返回，但局部变量 a 存在栈中，在离开作用域后，a 所申请的栈上内存都会被系统回收，从而造成了 悬空指针(Dangling Pointer) 的问题。

虽然编译可以通过，但是运行的时候会出现错误。

变量 c常量字符串，存储于常量区， "xyz" 只有当整个程序结束后系统才能回收这片内存。

# 栈(Stack)与堆(Heap)

栈中的所有数据都必须占用已知且固定大小的内存空间
对于大小未知或者可能变化的数据，需要存储在堆上
- 当向堆上放入数据时，需要请求一定大小的内存空间。操作系统在堆的某处找到一块足够大的空位，把它标记为已使用，并返回一个表示该位置地址的指针, 该过程被称为在堆上分配内存，有时简称为 “分配”(allocating)
- 接着，该指针会被推入栈中，因为指针的大小是已知且固定的，在后续使用过程中，你将通过栈中的指针，来获取数据在堆上的实际内存位置，进而访问该数据
写入
- 入栈比在堆上分配内存要快
- 入栈时操作系统无需分配新的空间，只需要将新数据放入栈顶即可
- 在堆上分配内存则需要更多的工作，这是因为操作系统必须首先找到一块足够存放数据的内存空间，接着做一些记录为下一次分配做准备
读取
- 得益于 CPU 高速缓存，使得处理器可以减少对内存的访问，高速缓存和内存的访问速度差异在 10 倍以上
- 栈数据往往可以直接存储在 CPU 高速缓存中，而堆数据只能存储在内存中
- 访问堆上的数据比访问栈上的数据慢，因为必须先访问栈再通过栈上的指针来访问内存

# 所有权原则

Rust 中每一个值都被一个变量所拥有，该变量被称为值的所有者
一个值同时只能被一个变量所拥有，或者说一个值只能拥有一个所有者
当所有者(变量)离开作用域范围时，这个值将被丢弃(drop)

# 变量绑定背后的数据交互

### 转移所有权

let x = 5;
let y = x;

两个值都是通过自动拷贝的方式来赋值的，都被存在栈中，完全无需在堆上分配内存

let s1 = String::from("hello");
let s2 = s1;

对于基本类型（存储在栈上），Rust 会自动拷贝，但是 String 不是基本类型，而且是存储在堆上的，因此不能自动拷贝。

String 类型是一个复杂类型，由存储在栈中的堆指针、字符串长度、字符串容量共同组成，其中堆指针是最重要的，它指向了真实存储字符串内容的堆内存，至于长度和容量，如果你有 Go 语言的经验，这里就很好理解：容量是堆内存分配空间的大小，长度是目前已经使用的大小。

String 类型指向了一个堆上的空间，这里存储着它的真实数据, 下面对上面代码中的 let s2 = s1 分成两种情况讨论：

拷贝 String 和存储在堆上的字节数组如果该语句是拷贝所有数据(深拷贝)，那么无论是 String 本身还是底层的堆上数据，都会被全部拷贝，这对于性能而言会造成非常大的影响
只拷贝 String 本身这样的拷贝非常快，因为在 64 位机器上就拷贝了 8字节的指针、8字节的长度、8字节的容量，总计 24 字节，但是带来了新的问题：一个值只允许有一个所有者，而现在这个值（堆上的真实字符串数据）有了两个所有者：s1 和 s2。

当变量离开作用域后，Rust 会自动调用 drop 函数并清理变量的堆内存。

当 s1 和 s2 离开作用域，它们都会尝试释放相同的内存。这是一个叫做 二次释放（double free） 的错误。

所以，Rust 这样解决问题：当 s1 赋予 s2 后，Rust 认为 s1 不再有效，因此也无需在 s1 离开作用域后 drop 任何东西，这就是把所有权从 s1 转移给了 s2，s1 在被赋予 s2 后就马上失效了。

看看在所有权转移后再来使用旧的所有者

let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1);

Rust 会禁止你使用无效的引用

move occurs because `s1` has type `std::string::String`, which does not implement the `Copy` trait

fn main() {
    let x: &str = "hello, world";
    let y = x;
    println!("{},{}",x,y);
}

x 只是引用了存储在二进制中的字符串 "hello, world"，并没有持有所有权。

因此 let y = x 中，仅仅是对该引用进行了拷贝，此时 y 和 x 都引用了同一个字符串。

### 克隆(深拷贝)

Rust 永远也不会自动创建数据的 “深拷贝”。任何自动的复制都不是深拷贝。

如果确实需要深度复制 String 中堆上的数据，而不仅仅是栈上的数据，可以使用一个叫做 clone 的方法。

let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);

s2 完整的复制了 s1 的数据

### 拷贝(浅拷贝)

浅拷贝只发生在栈上

Rust 有一个叫做 Copy 的特征，可以用在类似整型这样在栈中存储的类型。如果一个类型拥有 Copy 特征，一个旧的变量在被赋值给其他变量后仍然可用。

任何基本类型的组合可以 Copy ，不需要分配内存或某种形式资源的类型是可以 Copy 的。如下是一些 Copy 的类型：

所有整数类型
布尔类型
所有浮点数类型
字符类型
元组，当且仅当其包含的类型也都是 Copy 的时候
不可变引用 &T

# 引用与解引用

常规引用是一个指针类型，指向了对象存储的内存地址。

fn main() {
    let x = 5;
    let y = &x;

    assert_eq!(5, x);
    assert_eq!(5, *y);
}

# 不可变引用

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
    s.len()
}

通过 &s1 语法，我们创建了一个指向 s1 的引用，但是并不拥有它。因为并不拥有这个值，当引用离开作用域后，其指向的值也不会被丢弃。

# 可变引用

fn main() {
    let mut s = String::from("hello");
    change(&mut s);
}
fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

s 是可变类型，其次创建一个可变的引用 &mut s 和接受可变引用参数 some_string: &mut String 的函数。

可变引用同时只能存在一个

fn main() {
   let mut s = String::from("hello");
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // 新编译器中，r1,r2作用域在这里结束
    let r3 = &mut s;
    println!("{}", r3);
} // 老编译器中，r1、r2、r3作用域在这里结束
  // 新编译器中，r3作用域在这里结束

引用作用域的结束位置从花括号变成最后一次使用的位置，因此 r1 借用和 r2 借用在 println! 后，就结束了，此时 r3 可以顺利借用到可变引用。

## 悬垂引用(Dangling References)

指针指向某个值后，这个值被释放掉了，而指针仍然存在，其指向的内存可能不存在任何值或已被其它变量重新使用。

fn dangle() -> &String { // dangle 返回一个字符串的引用
    let s = String::from("hello"); // s 是一个新字符串
    &s // 返回字符串 s 的引用
} // 这里 s 离开作用域并被丢弃。其内存被释放。
  // 危险！

解决方法是直接返回 String：

fn no_dangle() -> String {
    let s = String::from("hello");
    s
}

String 的 所有权被转移给外面的调用者

Linux | tmpfs & tmpdir

xiayangzzw@gmail.com (inasayang) — Sun, 26 Feb 2023 00:00:00 Z

# tmpfs

Temporary File System的简称，数据存储在易失性内存中，而不是一个持久的存储设备。一个类似的结构是RAM磁盘，它显示为一个虚拟磁盘驱动器，并承载一个磁盘文件系统。

存储在tmpfs中的所有内容都是临时性的，即不会在非易失性存储器如硬盘上直接创建文件（尽管根据操作系统的页面替换策略，交换空间被用作备份存储）。重启时，tmpfs中的所有内容都会丢失。

临时文件所使用的内存会随着它所包含的文件而增长和缩小。

许多 Unix 发行版默认为文件系统的 /tmp 分支或共享内存启用和使用 tmpfs。可以通过 df 观察到。

而在几乎所有的Linux发行版上，都会在/run/或/var/run/上挂载一个tmpfs，以存储临时的运行时文件，如PID文件和Unix域套接字。临时的系统文件，如固件变量，存放在/sys。

由于RAM的速度比磁盘存储的速度高，tmpfs允许缓存在其中时速度更快，导致整个系统的效率更高，尽管带有页面缓存的操作系统看到的好处较少，因为如果可用内存足够，最近使用的文件页面会保留在内存中。由于RAM在重启时被清除，tmpfs防止系统变得过于杂乱，而不需要用户手动删除临时文件。此外，在RAM中存储文件可以防止磁盘过快填充，并通过减少写入量延长固态硬盘的寿命。

使用RAM来存储文件，而不是物理磁盘，这可以提高性能，减少由于磁盘故障造成的数据丢失风险。与物理磁盘相比，tmpfs的一个优点是速度更快，因为读写是在内存中进行的，而不是在较慢的物理磁盘上。然而，需要注意的是，tmpfs受到系统可用内存数量的限制，文件系统可能需要定期调整大小或清除，以避免内存耗尽。

┌───────────┬──────────────┬────────────────┐
│ /dev/shm  │ always tmpfs │ Linux specific │
├───────────┼──────────────┼────────────────┤
│ /tmp      │ can be tmpfs │ FHS 1.0        │
├───────────┼──────────────┼────────────────┤
│ /var/tmp  │ never tmpfs  │ FHS 1.0        │
└───────────┴──────────────┴────────────────┘

## /tmp

/tmp是一个目录，被系统和应用程序用来存储只在短时间内需要的临时文件。这些文件通常在系统重新启动时被删除。正因为如此，/tmp经常被用来存储运行中的应用程序需要的文件，如日志文件或临时数据。

## /var/tmp

/var/tmp用于长期存储临时文件，这些文件应在重启后持续存在。

一般来说，存储在/var/tmp中的文件不会被自动删除，而且它们的目的是在重启后仍然存在。然而，在某些情况下，/var/tmp中的文件可能会被删除，例如，当系统管理员进行系统维护或磁盘空间变满时。

值得注意的是，Linux文件系统层次标准（FHS）建议不要自动删除/var/tmp中的文件。然而，一些系统管理员可能会选择配置他们的系统来删除/var/tmp中一定时间内没有被访问或修改的文件。

## /dev/shm

/dev/shm是基于Unix的操作系统中的一个特殊目录，用于创建和访问共享内存段。共享内存是一种技术，它允许多个进程访问一个共同的内存区域，该区域可用于在它们之间共享数据。

在基于Unix的系统中，/dev/shm是一个虚拟文件系统，它提供了一个使用RAM磁盘的共享内存实现。当一个进程在/dev/shm中创建一个共享内存段时，操作系统会在RAM盘中创建一个新的文件，该文件有一个代表共享内存段的唯一名称。然后，这个文件可以被其他有必要权限的进程作为共享内存段使用，以访问它。

通过/dev/shm使用共享内存的好处是，它比其他进程间的通信方法（如管道或套接字）更快，因为数据不在进程间复制。相反，进程可以直接访问同一区域的内存，这可以提高性能并减少开销。

需要注意的是，/dev/shm中的共享内存段的内容是不稳定的，当系统重启或创建共享内存段的进程明确删除这些内存段时，这些内容就会丢失。因此，确保使用/dev/shm中的共享内存段的进程正确管理它们的创建和删除，以避免任何数据丢失或系统不稳定是很重要的。

Go | Build Constraints 构建约束

xiayangzzw@gmail.com (inasayang) — Mon, 02 Jan 2023 00:00:00 Z

一个构建约束(构建标签)是文件应包含在包中的条件。构建约束由开始的行注释给出。

//go:build

约束可以出现在任何类型的源文件中（不仅仅是 Go），但它们必须出现在文件顶部附近，前面只有空行和其他行注释。这些规则意味着在 Go 文件中，构建约束必须出现在 package 子句之前。

为了区分构建约束和包文档，构建约束后面应该跟一个空行。

构建约束注释被评估为包含由 ||、&& 和 ! 组合的构建标记的表达式,运算符和括号。

例如，当满足linux和386约束时，或者满足darwin而cgo不满足时，以下构建约束约束文件构建：

//go:build (linux && 386) || (darwin && !cgo)

一个文件有多个 //go:build 行是错误的。

在特定构建期间，满足以下构建标签：

目标操作系统，由 runtime.GOOS 拼写，使用 GOOS 环境变量设置。
目标体系结构，由 runtime.GOARCH 拼写，使用 GOARCH 环境变量设置。
unix，如果 GOOS 是 Unix 或类 Unix 系统。
正在使用的编译器，gc或gccgo
cgo，如果支持 cgo 命令（请参阅go help environment中的 CGO_ENABLED）。
每个 Go 主要版本的术语，通过当前版本：从 Go 1.1 版开始的“go1.1”，从 Go 1.12 开始的“go1.12”，等等。
-tags 标志给出的任何附加标签（参见go help build）。

如果文件名在去除扩展名和可能的 _test 后缀后匹配以下任何模式：

*_GOOS
*_GOARCH
*_GOOS_GOARCH

（示例：source_windows_amd64.go）其中 GOOS 和 GOARCH 分别代表任何已知的操作系统和体系结构值，然后该文件被认为具有需要这些术语的隐式构建约束（除了文件中的任何显式约束之外）。

除了 android 标签和文件之外，使用 GOOS=android 匹配构建标签和文件，就像 GOOS=linux 一样。
除了 illumos 标签和文件之外，使用 GOOS=illumos 匹配构建标签和文件，就像 GOOS=solaris 一样。
除了 ios 标签和文件之外，使用 GOOS=ios 匹配构建标签和文件，就像 GOOS=darwin 一样。

要阻止文件被考虑用于构建：

//go:build ignore

仅在使用 cgo 时构建文件，并且仅在 Linux 和 OS X 上：

//go:build cgo && (linux || darwin)

这样的文件通常与另一个实现其他系统默认功能的文件配对，在这种情况下会带有约束：

//go:build !(cgo && (linux || darwin))

将文件命名为 dns_windows.go 将导致它仅在为 Windows 构建包时被包含；同样，只有在为 32 位 x86 构建包时才会包含 math_386.s。

Go 版本 1.16 及更早版本使用不同的语法来构建约束，带有// +build前缀。 gofmt 命令将在遇到旧语法时添加等效的 //go:build 约束。

例外，下列使用空格，逗号，多行在新版本中已失效：

用空格分隔的构建标记在逻辑上是或
```
  // +build linux darwin
```
用逗号分隔的构建标记在逻辑上是和
```
// +build windows,386
```
在多行上构建约束是逻辑和
```
// +build windows
// +build 386
```

完整的约束标签可以在这里找到

Build constraints