Hugo Academic CV Theme

From unique to cleanups and weak new low-level tools for efficiency

Fri, 28 Mar 2025 00:00:00 +0000

📌 背景与动机

在过去，Go 语言提供了 runtime.SetFinalizer 方法来处理对象被垃圾回收时的清理操作（Finalizer）。
但 Finalizer 存在一些固有问题：

如果对象之间有循环引用，Finalizer 可能永远不会被调用，导致内存泄漏。
Finalizer 会延迟对象的回收，至少需要两个垃圾回收周期才能彻底清除对象。
Finalizer 有可能让对象“复活”（Resurrection），导致原本应被释放的对象意外存活下来，造成内存浪费。

因此，Go 在 1.24 版本推出了两个新功能：

runtime.AddCleanup：更安全的对象清理方法。
weak.Pointer：弱引用指针类型，可以引用对象但不会阻止对象被回收。

这两个功能结合使用，能有效解决传统 Finalizer 的问题，并构建更高效、更安全的数据结构，比如缓存或去重机制。

📌 一、`runtime.AddCleanup`（安全清理函数）

runtime.AddCleanup 允许给一个对象附加一个“清理函数”，当该对象变得不可达（即垃圾回收后）时，清理函数将被执行。

示例：使用内存映射文件（memory-mapped file）

package main

import (
 "os"
 "runtime"
 "syscall"
)

// MemoryMappedFile 表示一个内存映射文件对象
// 通过该对象可直接访问文件内容，无需反复读取磁盘
// 当对象不再使用时，会自动释放内存映射资源
type MemoryMappedFile struct {
    data []byte // 文件内容的内存映射区域
}

// NewMemoryMappedFile 创建一个内存映射文件对象
// filename: 需要被映射的文件路径
func NewMemoryMappedFile(filename string) (*MemoryMappedFile, error) {
    // 打开指定文件
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    // 确保函数结束时自动关闭文件句柄
    defer f.Close()

    // 获取文件信息（主要是为了获取文件大小）
    fi, err := f.Stat()
    if err != nil {
        return nil, err
    }

    // 获取底层系统的文件描述符（file descriptor）
    conn, err := f.SyscallConn()
    if err != nil {
        return nil, err
    }

    var data []byte
    // 使用conn.Control安全地拿到文件描述符并执行内存映射操作
    connErr := conn.Control(func(fd uintptr) {
    // syscall.Mmap 将文件内容映射到内存
    data, err = syscall.Mmap(
        int(fd),            // 文件描述符
        0,                  // 映射的起始位置，从文件头开始
        int(fi.Size()),     // 映射的长度为文件的大小
        syscall.PROT_READ,  // 映射区域权限：只读
        syscall.MAP_SHARED, // 共享模式，可被多个进程访问
    )
    })

    // 检查映射过程中是否发生错误
    if connErr != nil || err != nil {
        return nil, err
    }

    // 创建内存映射文件对象
    mf := &MemoryMappedFile{data: data}

    // 定义清理函数，用于释放内存映射资源
    cleanup := func(data []byte) {
        syscall.Munmap(data) // 当对象被垃圾回收时，自动解除内存映射
    }

    // 添加清理函数，当 mf 对象不再被引用时，自动调用 cleanup
    runtime.AddCleanup(mf, cleanup, data)

    return mf, nil
}

为什么比传统 Finalizer 更安全？

传统 Finalizer 的问题：清理函数的参数必须是原对象本身，会导致对象复活，延迟释放。
AddCleanup 改进：清理函数不再直接接收原对象，而是另外的独立参数，从而避免了对象复活问题，可以立即释放内存。

📌 二、`weak.Pointer`（弱引用指针）

弱引用指针允许引用一个对象，但这种引用不会阻止对象被垃圾回收。当对象被回收后，弱引用自动变成 nil。

示例：内存映射文件缓存（防止重复加载同一文件）

var cache sync.Map // 缓存文件映射: map[string]weak.Pointer[MemoryMappedFile]

func NewCachedMemoryMappedFile(filename string) (*MemoryMappedFile, error) {
    var newFile *MemoryMappedFile
    for {
        value, ok := cache.Load(filename)
        if !ok {
            if newFile == nil {
                var err error
                newFile, err = NewMemoryMappedFile(filename)
                if err != nil {
                    return nil, err
                }
            }

            wp := weak.Make(newFile)
            value, loaded := cache.LoadOrStore(filename, wp)
            if !loaded {
                runtime.AddCleanup(newFile, func(filename string) {
                    cache.CompareAndDelete(filename, wp)
                }, filename)
                return newFile, nil
            }
        }

        if mf := value.(weak.Pointer[MemoryMappedFile]).Value(); mf != nil {
            return mf, nil
        }

        cache.CompareAndDelete(filename, value)
    }
}

优势：

避免反复映射同一个文件，提升效率。
不需要手动确定何时移除缓存条目。当对象不再被使用，弱引用自动变为 nil，此时可以自动从缓存删除。

📌 三、组合使用与泛型扩展

利用泛型，weak.Pointer 和 runtime.AddCleanup 可用于构建通用缓存结构：

type Cache[K comparable, V any] struct {
    create func(K) (*V, error)
    m      sync.Map
}

func (c *Cache[K, V]) Get(key K) (*V, error) {
    var newValue *V
    for {
        value, ok := c.m.Load(key)
        if !ok {
            if newValue == nil {
                var err error
                newValue, err = c.create(key)
                if err != nil {
                    return nil, err
                }
            }

            wp := weak.Make(newValue)
            value, loaded := c.m.LoadOrStore(key, wp)
            if !loaded {
                runtime.AddCleanup(newValue, func(key K) {
                    c.m.CompareAndDelete(key, wp)
                }, key)
                return newValue, nil
            }
        }

        if v := value.(weak.Pointer[V]).Value(); v != nil {
            return v, nil
        }

        c.m.CompareAndDelete(key, value)
    }
}

📌 四、注意事项与未来方向

尽管更安全，runtime.AddCleanup 和 weak.Pointer 仍属于高级功能：

不要让对象和其清理函数互相引用，否则清理函数可能永远不会执行。
弱引用指针用作 Map 的键时，其对应的值不应引用该对象本身，否则对象可能永远无法回收。
清理操作本质上是非确定性的，难以严格测试和控制，使用时需谨慎考虑。

未来改进方向：

引入 Ephemeron（弱键映射）进一步改善弱引用使用体验。
提供垃圾收集器直接管理资源（如内存映射）的可能。

📌 五、为何现在才推出？

弱引用指针在 Go 中早已被讨论，但长期未被优先考虑：

它复杂微妙，容易误用，可能引入语言复杂度。
但如今泛型支持、对 Finalizer 的长期经验总结，以及其他语言（如 Java、C#）的经验，让这些功能的设计和推出变得成熟和可行。

📌 六、总结（功能对比）

功能	优势	缺陷	推荐用法
runtime.SetFinalizer	易用、简单	易造成内存泄漏或对象复活	不推荐，易误用
✅ runtime.AddCleanup	不造成对象复活，立即回收	高级用法，注意引用关系	资源清理，内存映射
✅ weak.Pointer	不影响垃圾回收，可实现自动缓存清理	非确定性，需谨慎使用	缓存、对象池、去重

综上所述，
Go 1.24 的新功能 runtime.AddCleanup 和 weak.Pointer 提供了更安全、高效的资源管理机制，避免了传统 Finalizer 的重大缺陷。但仍需谨慎合理使用，以避免引入新的复杂性。

Goodbye core types-Hello Go as we know and love it!

Fri, 28 Mar 2025 00:00:00 +0000

📌 一、理解背景：Go语言泛型（Generics）的引入

在 Go 1.18（2022年3月发布）以前，Go语言并没有泛型功能（generics）。所谓泛型就是写函数或数据结构时，可以不指定具体类型，而用类型参数代替，然后调用时再填入具体类型，这样函数可以用于很多不同类型的情况。

比如：

// 没有泛型之前，得为每种类型写一个函数
func SumInt(a, b int) int { return a + b }
func SumFloat(a, b float64) float64 { return a + b }

// 泛型后，可以只写一个函数：
func Sum[T int | float64](a, b T) T { return a + b }

泛型的引入使Go语言更灵活、更强大。但随之而来，语言内部实现变得复杂了。

📌 二、理解类型参数、类型约束和类型集

泛型中出现了一些重要概念：

类型参数（Type Parameter）

就是泛型函数或泛型结构体中用来代替具体类型的占位符，类似函数参数。
```
func Example[T any](value T) T {
    return value
}
```
这里T就是一个类型参数。
类型约束（Type Constraint）

表示一个类型参数能取哪些具体类型的限制。用接口表示：
```
type MyConstraint interface {
    ~string | ~[]byte
    Hash() uint64
}
```
这个约束表示任何底层类型是string或[]byte，并且实现了Hash()方法的类型都可以满足。
类型集（Type Set）

一个类型约束定义了一组满足特定条件的类型集合，称为“类型集”。上述例子中，类型集就是满足“底层类型是string或[]byte且带有Hash()方法”的所有类型的集合。

📌 三、“核心类型”（Core Type）到底是什么？

引入泛型之后，Go的实现者发现了一个问题：

以前语言规范里，很多操作（比如close、append、切片操作）都是直接说：“参数必须是通道”、“参数必须是切片或数组”。
但泛型出现后，有些操作的参数可能是类型参数，无法直接说清楚具体类型了。

为了解决这个问题，语言规范引入了一个抽象概念，称为核心类型（core type）。

核心类型的定义大致是：

非泛型情况：某个普通类型的核心类型就是它的底层类型（underlying type）。
比如：type MyInt int 的核心类型就是int。
泛型情况：若类型参数的类型集中的所有类型的底层类型都完全一样，则这个类型参数的核心类型就是那个共同的底层类型。
反之，如果类型集中有不同的底层类型，则不存在核心类型。

例如：

interface{ ~[]int }类型集只有一种底层类型（[]int），因此它的核心类型就是[]int。
interface{ ~[]byte | ~string }存在两种不同的底层类型（[]byte和string），因此这个接口不存在核心类型。

最初引入核心类型的原因很简单：就是为了语言规范方便叙述和编译器方便实现，避免处理泛型参数时总是考虑一堆类型的集合。

📌 四、核心类型存在的问题（为何要去掉？）

虽然核心类型初衷是为了简化泛型的实现，但实际使用中却带来了一些新问题：

问题1：规则过于严格，限制了语言扩展

因为核心类型要求类型集中所有类型必须有相同的底层类型，很多合理的泛型操作反而被禁止了。

例如，下面的约束就无法获得核心类型：
```
type Constraint interface {
    ~string | ~[]byte
    Hash() uint64
}
```
这样，使用泛型参数时，虽然直观上对字符串和字节数组的某些操作类似，但在核心类型的严格要求下无法实现。
问题2：增加了语言复杂性

很多简单的操作，比如：
```
close(ch) // 以前只要求 ch 是 channel 即可
```
现在规范里却变成了：

“参数的核心类型必须是通道类型”

这让普通的程序员在学习和理解非泛型代码时，也需要理解这个抽象而复杂的“核心类型”概念，给语言的学习造成负担。
问题3：导致了规则的不统一

因为存在核心类型的概念，某些正常的操作反而成为了语言规范的“特例”，比如len()、cap()、索引操作。

这种不统一性，反而使得语言变得更难懂、更难维护。

因此，核心类型在实践中变成了一个“鸡肋”，不仅没有真正让语言变简单，反而变复杂了。

📌 五、Go 1.25 做出了哪些改变？

基于以上问题，Go语言开发团队在即将到来的Go 1.25（2025年8月）中决定彻底废弃“核心类型”概念：

直接删掉了核心类型的定义。
规范中的每个操作，回到更直接的表述方式：

比如，原来：

“close函数的参数核心类型必须是通道”。

现在恢复为：

“close函数的参数必须是通道”。
针对泛型情况下，规范增加额外但直接明确的说明：

“若close函数的参数是类型参数，则类型集内所有类型必须为元素类型一致的通道类型。”

实际效果是

语言规范变简单了：普通程序员不再需要理解抽象的“核心类型”，语言回归直观和简单。
非泛型代码回归原样：不用再关心泛型相关的概念，操作的含义变得直接易懂。
泛型操作更灵活：未来可以更灵活地拓展，比如允许更丰富的类型操作，不再受核心类型概念的限制。

📌 六、总结与直观理解

泛型引入后 → 为了方便描述 → 出现了“核心类型”
实际使用后发现 → 核心类型不仅没简化，反而带来了复杂性
Go 1.25决定 → 删掉“核心类型”，回归简单直接的语言设计方式

简单来说，核心类型原本是为了解决泛型实现中遇到的问题，但实际带来了更大的复杂性。Go团队决定“回到初心”，取消这个概念，让语言规范更加易懂，更便于未来扩展。

到这里，相信你已经完全理解了这篇文章的来龙去脉以及为何 Go 决定废弃“核心类型”的原因。

Testing concurrent code with testing/synctest

Fri, 28 Mar 2025 00:00:00 +0000

使用testing/synctest测试并发代码

Go 的一个标志性特性是对并发的内建支持。Goroutine 和 channel 是用于编写并发程序的简单而有效的原语。

然而，测试并发程序可能是困难且容易出错的。

在 Go 1.24 中，我们引入了一个新的实验性包 testing/synctest，用于支持并发代码的测试。本文将解释该实验背后的动机，演示如何使用 synctest 包，并讨论其未来的潜力。

💡 testing/synctest 是实验性的，不受 Go 兼容性承诺的约束。
默认情况下不可见。要使用它，请在环境中设置：
GOEXPERIMENT=synctest

并发程序的测试很难

让我们从一个简单的例子开始。

context.AfterFunc 函数会安排在 context 被取消后调用一个函数，该函数会在自己的 goroutine 中执行。下面是一个可能用于测试 AfterFunc 的例子：

func TestAfterFunc(t *testing.T) {
    ctx, cancel := context.WithCancel(context.Background())

    calledCh := make(chan struct{}) // AfterFunc 被调用时关闭
    context.AfterFunc(ctx, func() {
        close(calledCh)
    })

    // TODO: 断言 AfterFunc 尚未被调用

    cancel()

    // TODO: 断言 AfterFunc 已经被调用
}

我们希望在这个测试中检查两个条件：

context 被取消前函数未被调用；
context 被取消后函数被调用。

在并发系统中检查一个“未发生的事件”是困难的。我们可以很容易地检查函数是否已经被调用，但要如何确认它还没被调用呢？

一种常见做法是等待一段时间，然后再断定某个事件没有发生。让我们试着在测试中引入一个辅助函数来实现这一点：

// funcCalled 报告函数是否被调用
funcCalled := func() bool {
    select {
    case <-calledCh:
        return true
    case <-time.After(10 * time.Millisecond):
        return false
    }
}

if funcCalled() {
    t.Fatalf("context 被取消前 AfterFunc 就被调用了")
}

cancel()

if !funcCalled() {
    t.Fatalf("context 被取消后 AfterFunc 没有被调用")
}

这个测试：

❌ 很慢：10 毫秒虽短，但在大量测试中会显著拖慢运行速度；
❌ 不稳定：10 毫秒对快机器来说已足够，但在 CI 等环境中可能不够，导致测试失败；
❌ 两难选择：等待时间长一些可减少不稳定性但会变慢，反之亦然。

引入 `testing/synctest` 包

synctest 包解决了这个问题。它允许我们将测试重写为简单、快速且可靠的形式，而无需修改被测试的代码。

该包只包含两个函数：

Run：在一个新的 goroutine 中调用一个函数，进入称为 “bubble” 的隔离环境；
Wait：等待 bubble 中的所有 goroutine 都阻塞在另一个 goroutine 上。

让我们用 synctest 包重写上面的测试：

func TestAfterFunc(t *testing.T) {
    synctest.Run(func() {
        ctx, cancel := context.WithCancel(context.Background())

        funcCalled := false
        context.AfterFunc(ctx, func() {
            funcCalled = true
        })

        synctest.Wait()
        if funcCalled {
            t.Fatalf("context 被取消前 AfterFunc 就被调用了")
        }

        cancel()

        synctest.Wait()
        if !funcCalled {
            t.Fatalf("context 被取消后 AfterFunc 没有被调用")
        }
    })
}

优势：

✅ 测试既快速又可靠；
✅ 代码更简洁：布尔变量替代 channel；
✅ 无竞态：Wait 提供同步，-race 也不会报错；
✅ 更安全：移除第二次 Wait 将触发竞态错误，说明检测生效。

时间相关的测试

并发代码常与时间有关。

使用真实时间进行测试会导致：

慢；
不稳定；
难以预测。

使用虚拟时间的传统方式通常要求你不用 time 包，而是自己实现时钟接口，非常繁琐。

synctest 中的虚拟时钟让你无需更改被测代码即可测试时间逻辑：

在 bubble 中，time.Sleep、WithTimeout 等使用虚拟时间；
时间只在所有 goroutine 都阻塞时推进。

示例：测试 `context.WithTimeout`

func TestWithTimeout(t *testing.T) {
    synctest.Run(func() {
        const timeout = 5 * time.Second
        ctx, cancel := context.WithTimeout(context.Background(), timeout)
        defer cancel()

        // 等待比超时时间略短一点
        time.Sleep(timeout - time.Nanosecond)
        synctest.Wait()
        if err := ctx.Err(); err != nil {
            t.Fatalf("超时前 ctx.Err() = %v；预期 nil", err)
        }

        // 再等待剩余时间
        time.Sleep(time.Nanosecond)
        synctest.Wait()
        if err := ctx.Err(); err != context.DeadlineExceeded {
            t.Fatalf("超时后 ctx.Err() = %v；预期 DeadlineExceeded", err)
        }
    })
}

阻塞与 Bubble

synctest 的核心在于 bubble 必须进入“持久阻塞”（durably blocked）状态：

所有 goroutine 被阻塞；
且只能被 bubble 内部的 goroutine 唤醒。

此时：

若有 Wait() 调用，则返回；
若没有，则虚拟时间推进；
若仍无解，视为死锁，Run 会 panic。

造成“持久阻塞”的情况

在 nil channel 上发送/接收；
阻塞在 bubble 中创建的 channel；
所有分支都阻塞的 select；
time.Sleep；
sync.Cond.Wait；
sync.WaitGroup.Wait。

`sync.Mutex`

使用 sync.Mutex 不会导致持久阻塞。

原因：mutex 可能在 bubble 外部被释放，不能确保同步安全。

Channels

bubble 中创建的 channel：

✅ 可以安全参与持久阻塞；
❌ 若从 bubble 外访问这些 channel，会 panic；
✅ 设计保障只在 bubble 内 goroutine 间通信。

I/O

外部 I/O（如网络）不会被视为持久阻塞：

网络读可能被系统内核、外部程序等唤醒；
即使通信双方都在 bubble 中，运行时也无法分辨；

✅ 推荐做法：使用 net.Pipe 创建内存中的连接替代真实网络。

Bubble 生命周期

Run 会一直运行，直到 bubble 中所有 goroutine 退出；
如果死锁或不可解除的阻塞，Run 会 panic；
✅ 所有后台 goroutine 必须在测试结束前退出。

测试网络代码：`Expect: 100-continue`

HTTP 客户端发送 PUT 请求时可带 "Expect: 100-continue"，告诉服务器：

“我还有 body，要不要我继续发？”

服务器可返回：

100 Continue：允许发；
其他状态码：不允许发。

我们要验证客户端行为是否符合预期。

测试结构

synctest.Run(func() {
    srvConn, cliConn := net.Pipe()
    defer srvConn.Close()
    defer cliConn.Close()
    tr := &http.Transport{
        DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
            return cliConn, nil
        },
        ExpectContinueTimeout: 5 * time.Second,
    }

    body := "request body"
    go func() {
        req, _ := http.NewRequest("PUT", "http://test.tld/", strings.NewReader(body))
        req.Header.Set("Expect", "100-continue")
        resp, err := tr.RoundTrip(req)
        if err != nil {
            t.Errorf("RoundTrip 出现错误：%v", err)
        } else {
            resp.Body.Close()
        }
    }()

    req, err := http.ReadRequest(bufio.NewReader(srvConn))
    if err != nil {
        t.Fatalf("读取请求失败：%v", err)
    }

    var gotBody strings.Builder
    go io.Copy(&gotBody, req.Body)
    synctest.Wait()
    if got := gotBody.String(); got != "" {
        t.Fatalf("未收到 100 Continue 前已读到 body：%q", got)
    }

    srvConn.Write([]byte("HTTP/1.1 100 Continue\r\n\r\n"))
    synctest.Wait()
    if got := gotBody.String(); got != body {
        t.Fatalf("发送 100 Continue 后读取到的 body 为 %q，预期 %q", got, body)
    }

    srvConn.Write([]byte("HTTP/1.1 200 OK\r\n\r\n"))
})

这个测试还可扩展为：

✅ 未收到 100，不发送正文；
✅ 超时后才发送；
✅ 响应拒绝内容，不发送正文。

实验状态

testing/synctest 是 实验性包，默认不可见。

使用方式

GOEXPERIMENT=synctest go test

Traversal-resistant file APIs

Fri, 28 Mar 2025 00:00:00 +0000

📌 一、路径遍历攻击是什么？

路径遍历（Path Traversal）攻击是一种安全漏洞，攻击者通过控制程序访问文件的路径，使程序打开了原本未授权访问的敏感文件。

📌 二、典型漏洞示例（易受攻击的代码）

存在漏洞的代码通常长这样：

// baseDirectory 是受信任的固定目录
// filename 是用户可控制的输入
f, err := os.Open(filepath.Join(baseDirectory, filename))

为什么这段代码有漏洞？

假设：

baseDirectory := "/var/www/data"
filename := "../../../../etc/passwd"

执行后：

filepath.Join("/var/www/data", "../../../../etc/passwd")
// 实际路径："/etc/passwd"

攻击者成功跳出了本来限定的目录（/var/www/data），访问到了敏感文件。

📌 三、为什么传统路径检查不够安全？

你可能会想自己手动验证，比如：

// 手动检查路径安全性（不推荐）
if strings.Contains(filename, "..") {
    return errors.New("路径不安全")
}
f, err := os.Open(filepath.Join(baseDirectory, filename))

但这种检查方式不安全，原因如下：

易被绕过：复杂路径组合（如..././../）或绝对路径难以完全覆盖；
跨平台问题：Windows 和 Unix/Linux 系统对路径的理解不同，Windows 还涉及特殊设备名；
TOCTOU攻击：
攻击者可以在你的检查完成后、程序真正打开文件之前，通过修改符号链接或路径结构，仍旧绕过检查。

📌 四、Go 1.24 提供的安全方案：`os.Root` / `os.OpenInRoot`

为彻底解决上述问题，Go 1.24 推出了新的 API：

安全代码示例如下：

// 安全的代码，彻底防止路径逃逸
f, err := os.OpenInRoot(baseDirectory, filename)

它为什么安全？

os.OpenInRoot 内部机制：

首先打开并锁定根目录（如/var/www/data）；
自动检查用户提供的路径，绝不允许路径逃逸（如通过../）；
使用平台原生API（如Unix/Linux 的openat）防止符号链接攻击；
Windows 平台防止特殊设备名访问，如COM1、NUL。

📌 五、平台差异和注意事项

平台	说明
Unix/Linux	用`openat`系统调用防止逃逸，但无法阻止root用户创建的挂载点（如bind mount）攻击。
Windows	通过句柄锁定目录，阻止目录被重命名或删除；禁止访问特殊设备名。
WASI	安全性取决于WASI实现的沙箱特性。
GOOS=js (Node.js环境)	无法有效抵御TOCTOU攻击，因为缺少`openat`函数。
Plan 9	没有符号链接，直接进行路径词法检查。

📌 六、性能问题与优化

使用os.Root或os.OpenInRoot处理复杂路径（大量../）效率稍低；
建议提前使用filepath.Clean清理路径来提高性能。

📌 七、什么时候必须使用 `os.Root`？

满足以下条件必须使用：

你要打开的文件位于某个指定的根目录内；
文件路径来自外部用户的输入或不可信来源。

例如：

解压zip/tar文件到特定目录；
用户上传文件，必须限制到特定文件夹。

📌 八、完整总结与建议

方式	是否安全	理由
✅ `os.OpenInRoot(baseDirectory, filename)`	安全	内置安全机制，路径无法逃逸
❌ `os.Open(filepath.Join(baseDirectory, filename))`	不安全	可通过路径遍历(`../`)攻击逃出
❌ 手动检查路径（如`strings.Contains("..")`）	不安全	易绕过，且易受TOCTOU攻击

因此，推荐始终使用os.OpenInRoot或os.Root处理外部来源路径，有效防范路径遍历攻击。

以上即为路径遍历攻击及 Go 1.24 中新安全 API 完整详细的总结和解释。

fuck the life!

Sat, 28 Dec 2024 00:00:00 +0000

随笔

最近有点迷茫，要学的东西很多，但是没有动力学习

fuck the life!

Mon, 16 Dec 2024 00:00:00 +0000

随笔

不知道写点什么，就随便写写

Projects

Sun, 19 May 2024 00:00:00 +0000

摄影基础知识系列-1

Sun, 07 Jan 2024 00:00:00 +0000

前置知识

对比度

对比度是图像中最亮和最暗区域之间的亮度差异，决定了画面的视觉冲击力和层次感

高对比度：图像中的亮部非常亮，暗部非常暗，中间的灰阶较少。常见于戏剧性或剪影风格的摄影，可以带来强烈的视觉冲击力
- 优点：突出主体、创造戏剧效果
- 缺点：可能丢失细节，特别是在亮部或暗部
低对比度：图像中的亮暗区域差异较小，过渡柔和，通常用于表现柔美、平静或细腻的氛围
- 优点：细节丰富，适合表现复杂的纹理和场景
- 缺点：可能显得平淡，不够有力

饱和度

饱和度是用来描述色彩的鲜艳程度

高饱和度：色彩鲜艳、明亮，适合表现活力、热情
低饱和度：色彩柔和甚至趋于灰色，适合表达宁静、怀旧或低调的氛围

曝光

曝光是指传感器接收到的光线总量。它由光圈、快门速度和感光度（ISO）共同决定

曝光过度：图像整体偏亮，亮部可能失去细节
曝光不足：图像整体偏暗，暗部细节可能丢失

对比度与曝光的关系：

曝光过度会减少对比度，尤其是高光区域
曝光不足也会降低对比度，特别是在暗部区域

色调 (Tones)

色调描述的是图像中明暗关系的分布

高调摄影：图像整体偏亮，适合表现柔和、梦幻或优雅的主题
低调摄影：图像整体偏暗，适合表现神秘、戏剧性或压抑的情绪

清晰度

调整图像中中间调区域的对比度，增强纹理和细节

提高细节感和锐利感，使图像更加立体
降低清晰度可以让画面显得柔和或梦幻

锐化

增强图像边缘的清晰感，使模糊的部分看起来更锐利

提升图像边缘细节，用于打印或网络展示
注意不要过度锐化，否则会产生噪点或光晕

噪点

图像中的随机像素干扰，通常在高感光度（ISO）拍摄时出现

降噪：减少图像中的颗粒感，适合夜景或高ISO照片
添加噪点：可用作艺术效果，模仿胶片质感

白平衡

控制图像的整体色温（冷暖）和色调（绿色或洋红色偏向）

校正因光源导致的偏色问题
用作创意效果，例如暖色调的日落或冷色调的夜景

色彩分离

给图像的高光和阴影分别添加不同的颜色，创造特定氛围

增强画面色彩对比或艺术效果
常用于复古、电影风格调色

渐晕

调整图像四角的亮度，使边缘变暗或变亮

边缘变暗可聚焦主体
边缘变亮适合柔和、梦幻效果

色彩校正

调整画面整体或局部的色彩，让图像符合某种艺术风格

实现电影风、复古风等特定效果
强调或减弱某种颜色

色域调整

选择性调整某些颜色的表现（如红色、黄色、蓝色等）

加强特定颜色的饱和度或亮度
改变颜色的倾向（如将蓝天调为紫色）

变形和透视校正

调整图像的透视或几何形状

校正建筑物的变形（例如倾斜的线条）
创造戏剧性的视角效果

色调映射

将高动态范围（HDR）图像压缩到标准动态范围，保留亮部和暗部的细节

制作逼真的HDR效果
增强高动态范围场景的表现

模糊效果

控制画面的模糊程度以突出主体或创造艺术效果

景深模糊：模拟大光圈的浅景深效果
运动模糊：表现速度感

亮度蒙版

根据图像的亮度信息创建蒙版，精准调整特定区域

精细调整高光、阴影或中间调
专业调色和细节优化

背景替换和移除

改变图像背景或去除多余元素

重新构图或创造全新场景

Efficient Differentially Private Tensor Factorization in the Parallel and Distributed Computing Paradigm

Thu, 21 Dec 2023 00:00:00 +0000

Pandas

Thu, 26 Oct 2023 00:00:00 +0000

Flexible and powerful data analysis / manipulation library for Python, providing labeled data structures.

PyTorch

Thu, 26 Oct 2023 00:00:00 +0000

PyTorch is a Python package that provides tensor computation (like NumPy) with strong GPU acceleration.

scikit-learn

Thu, 26 Oct 2023 00:00:00 +0000

scikit-learn is a Python module for machine learning built on top of SciPy and is distributed under the 3-Clause BSD license.

Experience

Tue, 24 Oct 2023 00:00:00 +0000

Learn JavaScript

Tue, 24 Oct 2023 00:00:00 +0000

Hugo Blox Builder is designed to give technical content creators a seamless experience. You can focus on the content and the Hugo Blox Builder which this template is built upon handles the rest.

Embed videos, podcasts, code, LaTeX math, and even test students!

On this page, you’ll find some examples of the types of technical content that can be rendered with Hugo Blox.

Video

Teach your course by sharing videos with your students. Choose from one of the following approaches:

Youtube:

{{< youtube w7Ft2ymGmfc >}}

Bilibili:

{{< bilibili id="BV1WV4y1r7DF" >}}

Video file

Videos may be added to a page by either placing them in your assets/media/ media library or in your page’s folder, and then embedding them with the video shortcode:

{{< video src="my_video.mp4" controls="yes" >}}

Podcast

You can add a podcast or music to a page by placing the MP3 file in the page’s folder or the media library folder and then embedding the audio on your page with the audio shortcode:

{{< audio src="ambient-piano.mp3" >}}

Try it out:

Test students

Provide a simple yet fun self-assessment by revealing the solutions to challenges with the spoiler shortcode:

{{< spoiler text="👉 Click to view the solution" >}}
You found me!
{{< /spoiler >}}

renders as

👉 Click to view the solution

You found me 🎉

Math

Hugo Blox Builder supports a Markdown extension for $\LaTeX$ math. You can enable this feature by toggling the math option in your config/_default/params.yaml file.

To render inline or block math, wrap your LaTeX math with {{< math >}}$...${{< /math >}} or {{< math >}}$$...$${{< /math >}}, respectively.

We wrap the LaTeX math in the Hugo Blox math shortcode to prevent Hugo rendering our math as Markdown.

Example math block:

{{< math >}}
$$
\gamma_{n} = \frac{ \left | \left (\mathbf x_{n} - \mathbf x_{n-1} \right )^T \left [\nabla F (\mathbf x_{n}) - \nabla F (\mathbf x_{n-1}) \right ] \right |}{\left \|\nabla F(\mathbf{x}_{n}) - \nabla F(\mathbf{x}_{n-1}) \right \|^2}
$$
{{< /math >}}

renders as

$$\gamma_{n} = \frac{ \left | \left (\mathbf x_{n} - \mathbf x_{n-1} \right )^T \left [\nabla F (\mathbf x_{n}) - \nabla F (\mathbf x_{n-1}) \right ] \right |}{\left \|\nabla F(\mathbf{x}_{n}) - \nabla F(\mathbf{x}_{n-1}) \right \|^2}$$

Example inline math {{< math >}}$\nabla F(\mathbf{x}_{n})${{< /math >}} renders as $\nabla F(\mathbf{x}_{n})$ .

Example multi-line math using the math linebreak (\\):

{{< math >}}
$$f(k;p_{0}^{*}) = \begin{cases}p_{0}^{*} & \text{if }k=1, \\
1-p_{0}^{*} & \text{if }k=0.\end{cases}$$
{{< /math >}}

renders as

$$ f(k;p_{0}^{*}) = \begin{cases}p_{0}^{*} & \text{if }k=1, \\ 1-p_{0}^{*} & \text{if }k=0.\end{cases} $$

Code

Hugo Blox Builder utilises Hugo’s Markdown extension for highlighting code syntax. The code theme can be selected in the config/_default/params.yaml file.

```python
import pandas as pd
data = pd.read_csv("data.csv")
data.head()
```

renders as

import pandas as pd
data = pd.read_csv("data.csv")
data.head()

Inline Images

{{< icon name="python" >}} Python

renders as

Python

Learn Python

Tue, 24 Oct 2023 00:00:00 +0000

Hugo Blox Builder is designed to give technical content creators a seamless experience. You can focus on the content and the Hugo Blox Builder which this template is built upon handles the rest.

Embed videos, podcasts, code, LaTeX math, and even test students!

On this page, you’ll find some examples of the types of technical content that can be rendered with Hugo Blox.

Video

Teach your course by sharing videos with your students. Choose from one of the following approaches:

Youtube:

{{< youtube w7Ft2ymGmfc >}}

Bilibili:

{{< bilibili id="BV1WV4y1r7DF" >}}

Video file

Videos may be added to a page by either placing them in your assets/media/ media library or in your page’s folder, and then embedding them with the video shortcode:

{{< video src="my_video.mp4" controls="yes" >}}

Podcast

You can add a podcast or music to a page by placing the MP3 file in the page’s folder or the media library folder and then embedding the audio on your page with the audio shortcode:

{{< audio src="ambient-piano.mp3" >}}

Try it out:

Test students

Provide a simple yet fun self-assessment by revealing the solutions to challenges with the spoiler shortcode:

{{< spoiler text="👉 Click to view the solution" >}}
You found me!
{{< /spoiler >}}

renders as

👉 Click to view the solution

You found me 🎉

Math

Hugo Blox Builder supports a Markdown extension for $\LaTeX$ math. You can enable this feature by toggling the math option in your config/_default/params.yaml file.

To render inline or block math, wrap your LaTeX math with {{< math >}}$...${{< /math >}} or {{< math >}}$$...$${{< /math >}}, respectively.

We wrap the LaTeX math in the Hugo Blox math shortcode to prevent Hugo rendering our math as Markdown.

Example math block:

{{< math >}}
$$
\gamma_{n} = \frac{ \left | \left (\mathbf x_{n} - \mathbf x_{n-1} \right )^T \left [\nabla F (\mathbf x_{n}) - \nabla F (\mathbf x_{n-1}) \right ] \right |}{\left \|\nabla F(\mathbf{x}_{n}) - \nabla F(\mathbf{x}_{n-1}) \right \|^2}
$$
{{< /math >}}

renders as

Example inline math {{< math >}}$\nabla F(\mathbf{x}_{n})${{< /math >}} renders as $\nabla F(\mathbf{x}_{n})$ .

Example multi-line math using the math linebreak (\\):

{{< math >}}
$$f(k;p_{0}^{*}) = \begin{cases}p_{0}^{*} & \text{if }k=1, \\
1-p_{0}^{*} & \text{if }k=0.\end{cases}$$
{{< /math >}}

renders as

$$ f(k;p_{0}^{*}) = \begin{cases}p_{0}^{*} & \text{if }k=1, \\ 1-p_{0}^{*} & \text{if }k=0.\end{cases} $$

Code

Hugo Blox Builder utilises Hugo’s Markdown extension for highlighting code syntax. The code theme can be selected in the config/_default/params.yaml file.

```python
import pandas as pd
data = pd.read_csv("data.csv")
data.head()
```

renders as

import pandas as pd
data = pd.read_csv("data.csv")
data.head()

Inline Images

{{< icon name="python" >}} Python

renders as

Python

Hugo Academic CV Theme

From unique to cleanups and weak new low-level tools for efficiency

📌 背景与动机

📌 一、runtime.AddCleanup（安全清理函数）

为什么比传统 Finalizer 更安全？

📌 二、weak.Pointer（弱引用指针）

📌 三、组合使用与泛型扩展

📌 四、注意事项与未来方向

📌 五、为何现在才推出？

📌 六、总结（功能对比）

Goodbye core types-Hello Go as we know and love it!

📌 一、理解背景：Go语言泛型（Generics）的引入

📌 二、理解类型参数、类型约束和类型集

类型参数（Type Parameter）

类型约束（Type Constraint）

类型集（Type Set）

📌 三、“核心类型”（Core Type）到底是什么？

📌 四、核心类型存在的问题（为何要去掉？）

📌 五、Go 1.25 做出了哪些改变？

实际效果是

📌 六、总结与直观理解

Testing concurrent code with testing/synctest

使用testing/synctest测试并发代码

并发程序的测试很难

引入 testing/synctest 包

时间相关的测试

示例：测试 context.WithTimeout

阻塞与 Bubble

造成“持久阻塞”的情况

sync.Mutex

Channels

I/O

Bubble 生命周期

测试网络代码：Expect: 100-continue

测试结构

实验状态

使用方式

Traversal-resistant file APIs

📌 一、路径遍历攻击是什么？

📌 二、典型漏洞示例（易受攻击的代码）

📌 三、为什么传统路径检查不够安全？

📌 四、Go 1.24 提供的安全方案：os.Root / os.OpenInRoot

它为什么安全？

📌 五、平台差异和注意事项

📌 六、性能问题与优化

📌 七、什么时候必须使用 os.Root？

📌 八、完整总结与建议

fuck the life!

随笔

fuck the life!

随笔

Projects

摄影基础知识系列-1

前置知识

对比度

饱和度

曝光

色调 (Tones)

清晰度

锐化

噪点

白平衡

色彩分离

渐晕

色彩校正

色域调整

变形和透视校正

色调映射

模糊效果

亮度蒙版

背景替换和移除

Efficient Differentially Private Tensor Factorization in the Parallel and Distributed Computing Paradigm

Pandas

PyTorch

scikit-learn

Experience

Learn JavaScript

Video

Podcast

Test students

📌 一、`runtime.AddCleanup`（安全清理函数）

📌 二、`weak.Pointer`（弱引用指针）

引入 `testing/synctest` 包

示例：测试 `context.WithTimeout`

`sync.Mutex`

测试网络代码：`Expect: 100-continue`

📌 四、Go 1.24 提供的安全方案：`os.Root` / `os.OpenInRoot`

📌 七、什么时候必须使用 `os.Root`？