卡bug的个人网站

2026年许愿

Mon, 16 Feb 2026 13:44:25 +0800

即便AI编程出来了，但是我想，从编程之中享受建构的乐趣，HappyHacking，玩技术是快乐的。特别是玩Emacs，玩Linux，这是我一直所爱的技术。

1- hylang扩展emacs (不玩elisp)
     elisp全是操作buffer的，没想明白，看了之后觉得特无趣，但emacs写代码获得的心流体验是非常不错的
2- 中步深入Linux体系
3- 构建 AI生成应用的方法论
4- 源源不断从Emacs，Linux，Hylang的Hacking获得快乐
5- 肉体续航到达120KM
6- Opencode玩透
7- Emacs+Opencode+Aider

既然是许愿，那么结果并不重要

2025年的许愿
https://kbug.cn/post/850.html

赤子仁怀 2025年

Mon, 16 Feb 2026 13:42:47 +0800

凡所有相，皆是虚妄，一切有为法，如梦幻泡影。

回顾2025年许愿：

1. 搞Rust，基于rust写个好玩的项目 
    基本抛弃Rust了，不可能再玩Rust，没有意义，使用Go就够了。现在的路线是 Go，Py，Ts
2. 玩emacs，基于原生的emacs的思维，重新配置一套极简的emacs配置 
    年尾的时候，把elisp intro看了，然后把hylang看了，打算用hylang接py生态玩emacs
3. 明朝那些事儿
    不贪著其事，我现在没有时间看这些
4. 体重-20斤
    平常心看待结果
5. 写5篇技术博客
    不贪著其事
6. 初步深入学习linux操作系统
    挺好，继续跟进，这是我最初的心愿

2026年许愿：

即便AI编程出来了，但是我想，从编程之中享受建构的乐趣，HappyHacking，玩技术是快乐的。特别是玩Emacs，玩Linux，这是我一直所爱的技术。

1- hylang扩展emacs (不玩elisp)
     elisp全是操作buffer的，没想明白，看了之后觉得特无趣，但emacs写代码获得的心流体验是非常不错的
2- 中步深入Linux体系
3- 构建 AI生成应用的方法论
4- 源源不断从Emacs，Linux，Hylang的Hacking获得快乐
5- 肉体续航到达120KM
6- Opencode玩透
7- Emacs+Opencode+Aider

systemd简易笔记

Mon, 01 Dec 2025 00:07:38 +0800

Linux服务治理

需要阅读

了解为什么要将二进制先拷到 /usr/local/bin，不然就会被SELinux拦截

chap-security-enhanced_linux-troubleshooting

查看审计日志

grep "go_notify" /var/log/audit/audit.log

Systemd Unit Type

simple
使用systemctl start 时不会报错
exec
和simple差不多
会报错
forking
可能跟某个历史遗产有关，文档上不建议用，建议使用notify,notify-reload
oneshot
专为一次执行，无须长期驻留
dbus
dbus应用的话直接Type=dbus最合适，其能根据dbusname作判断active依据
#whatisd-bus
notify
如果服务需要加载一会儿，然后再通知systemd自己已激活，需要用这个，支持reloading的服务，则用下面的
notify-reload
idle
待所有工作都激活后才执行，可强制设置时间

其详解文档位置

systemd.service.html#Type=

systemd服务，Type=notify

如果普通的main进程，运行后就能获得反馈，不需要时间加载配置什么的，直接使用Type=exec，比simple更好

[Unit]
Description=practice go notify
After=network.target

[Service]
Type=notify
TimeoutStartSec=12
#WatchdogSecs=10s
#Restart=on-failure
ExecStart=/usr/local/bin/go_notify
TimeoutStopSec=5s

[Install]
WantedBy=multi-user.target

go示例

package main

import (
        "context"
        "log"
        "os"
        "os/signal"
        "syscall"
        "time"

        "github.com/coreos/go-systemd/v22/daemon"
)

const (
        // 模拟初始化耗时
        initDuration = 5 * time.Second
        // 业务循环间隔
        workInterval = 2 * time.Second
)

func main() {
        log.SetPrefix("notify-demo ")
        log.Println("starting...")

        // 1. 如果环境变量不在，直接退出（方便本地测试）
        notifySocket := os.Getenv("NOTIFY_SOCKET")
        if notifySocket == "" {
                log.Fatal("NOTIFY_SOCKET not set, run me under systemd")
        }
        log.Printf("NOTIFY_SOCKET=%s", notifySocket)

        // 2. 模拟“重量级”初始化
        log.Printf("初始化中，预计 %v ...", initDuration)
        time.Sleep(initDuration)

        // 3. 通知 systemd：我已经准备好了
        sent, err := daemon.SdNotify(false, daemon.SdNotifyReady)
        if err != nil {
                log.Fatalf("SdNotify(READY=1) failed: %v", err)
        }
        if !sent {
                log.Fatal("systemd 没有收到 READY=1（返回值=false）")
        }
        log.Println("已向 systemd 发送 READY=1")

        // 4. 看门狗相关
        //    如果单元文件里写了 WatchdogSec=10s，那么 systemd
        //    会每 10/2=5s 检查一次 WATCHDOG=1 是否到达。
        interval, err := daemon.SdWatchdogEnabled(false)
        if err != nil {
                log.Fatalf("SdWatchdogEnabled error: %v", err)
        }
        if interval > 0 {
                log.Printf("看门狗已启用，周期 %v，将周期性发送 WATCHDOG=1", interval)
        } else {
                log.Println("看门狗未启用（单元文件没写 WatchdogSec=）")
        }

        // 5. 业务主循环 + 信号处理
        ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
        defer stop()

        tick := time.NewTicker(workInterval)
        defer tick.Stop()

        if interval > 0 {
                // 启动独立 goroutine 喂狗
                go watchdogLoop(interval)
        }

        for {
                select {
                case <-ctx.Done():
                        log.Println("收到信号，开始优雅退出...")
                        // 这里可以关闭连接、刷盘等
                        time.Sleep(1 * time.Second) // 模拟清理
                        log.Println("bye~")
                        return
                case <-tick.C:
                        log.Println("业务心跳：doing useful work...")
                }
        }
}

// watchdogLoop 每 <interval/2> 发一次 WATCHDOG=1
func watchdogLoop(interval time.Duration) {
        t := time.NewTicker(interval / 2)
        defer t.Stop()
        for {
                <-t.C
                if sent, err := daemon.SdNotify(false, daemon.SdNotifyWatchdog); err != nil {
                        log.Printf("WATCHDOG=1 发送失败: %v", err)
                } else if !sent {
                        log.Println("WATCHDOG=1 未被 systemd 接收")
                }
        }
}

control group

A Linux SysAdmin’s introduction to cgroups
cgroups-part-one
How to manage cgroups with CPUShares
cgroups-part-two
Managing cgroups the hard way-manually
cgroups-part-three
Managing cgroups with systemd
cgroups-part-four

以及第四节的资源看一下。

逆天，systemd这整套体系，如此之大。

systemd.resource-control.html#Options

示例

#!/usr/bin/env python3
import time
import logging
import signal
import sys

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[logging.FileHandler('/var/log/demo-py-service.log'),
              logging.StreamHandler()]
)

shutdown = False
def _term(signum, frame):
    global shutdown
    shutdown = True
signal.signal(signal.SIGTERM, _term)

while not shutdown:
    logging.info("demo-py-service is alive")
    time.sleep(10)
logging.info("demo-py-service exiting")

[Unit]
Description=Demo Cgroup python
After=network.target

[Service]
Type=exec
ExecStart=/usr/bin/python3 /usr/local/bin/cgroup_py.py
Restart=on-failure
RestartSec=5s

User=nobody
Group=nobody

MemoryMax=50M
CPUQuota=20%

StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

关于限制方面的字段设置，需要参考 man systemd.resource-control OPTIONS

systemd-resoved

Systemd-resolved

man systemd-resolved
man resolved.conf
man resolvectl
man nss-resolve

systemd-resolved is a system service that provides network name resolution to local applications. It implements a caching and validating DNS/DNSSEC stub resolver, as well as an LLMNR and MulticastDNS resolver and responder. Local applications may submit network name resolution requests via three interface

我之前写毕业设计的时候，改resolve文件，一直过一会儿就失败，让我非常的恼火。然后发现，文档里写着，这是通过 systemd-resolved来管理的，不要修改他。

毕业设计的内容，其实就是控制dns解析。然后需要改dns服务器。

# This is /run/systemd/resolve/stub-resolv.conf managed by man:systemd-resolved(8).
# Do not edit.
#
# This file might be symlinked as /etc/resolv.conf. If you're looking at
# /etc/resolv.conf and seeing this text, you have followed the symlink.
#
# This is a dynamic resolv.conf file for connecting local clients to the
# internal DNS stub resolver of systemd-resolved. This file lists all
# configured search domains.
#
# Run "resolvectl status" to see details about the uplink DNS servers
# currently in use.
#
# Third party programs should typically not access this file directly, but only
# through the symlink at /etc/resolv.conf. To manage man:resolv.conf(5) in a
# different way, replace this symlink by a static file or a different symlink.
#
# See man:systemd-resolved.service(8) for details about the supported modes of
# operation for /etc/resolv.conf.

nameserver 127.0.0.53
options edns0 trust-ad
search .

go-daemon-template

systemd, cgroup, go 综合起来的一个项目，作systemd刻意练习

示例

[Unit]
Description=GD
After=network.target

[Service]
Type=exec
ExecStart=/usr/local/bin/go-daemon-template
Restart=on-failure
RestartSec=5s

User=nobody
Group=nobody

MemoryMax=500M
#CPUQuota=60%

StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

go-daemon-template 可以用htop查看，cgroup生效情况

package main

import (
        "fmt"
        "log"
        "net/http"
        "runtime"
        "strconv"
        "sync"
)

var (
        cpuStopCh chan struct{} // 广播停止 CPU 负载
        cpuWg     sync.WaitGroup
        memBuf    [][]byte      // 持有大块内存
        memMu     sync.Mutex
)

func init() {
        cpuStopCh = make(chan struct{})
}

// 死循环占满 1 个 P
func cpuBurner() {
        defer cpuWg.Done()
        for {
                select {
                case <-cpuStopCh:
                        return
                default:
                        // 纯计算，不让出时间片
                        for i := 0; i < 1e6; i++ {
                        }
                }
        }
}

// 模拟 CPU 占用
func setCPU(cores int) {
        // 先停掉旧的
        close(cpuStopCh)
        cpuWg.Wait()

        // 重新初始化
        cpuStopCh = make(chan struct{})
        cpuWg.Add(cores)
        for i := 0; i < cores; i++ {
                go cpuBurner()
        }
}

// 模拟内存占用
func setMemory(mb int) {
        memMu.Lock()
        defer memMu.Unlock()

        // 先释放旧的
        memBuf = nil
        runtime.GC()

        // 申请新的
        block := 1024 * 1024 // 1 MB
        total := mb * block
        slice := make([]byte, total)
        // 写一遍，避免懒分配
        for i := range slice {
                slice[i] = 0
        }
        // 切成 1 MB 一份，方便后面扩缩
        for i := 0; i < mb; i++ {
                memBuf = append(memBuf, slice[i*block:(i+1)*block])
        }
}

func queryHandler(w http.ResponseWriter, r *http.Request) {
        q := r.URL.Query()

        // --- CPU ---
        cpuStr := q.Get("cpu")
        if cpuStr != "" {
                cores, err := strconv.Atoi(cpuStr)
                if err != nil || cores < 0 {
                        http.Error(w, "cpu must be non-negative integer", http.StatusBadRequest)
                        return
                }
                setCPU(cores)
        }

        // --- Memory ---
        memStr := q.Get("memory")
        if memStr != "" {
                mb, err := strconv.Atoi(memStr)
                if err != nil || mb < 0 {
                        http.Error(w, "memory must be non-negative integer", http.StatusBadRequest)
                        return
                }
                setMemory(mb)
        }

        // 返回当前状态
        var m runtime.MemStats
        runtime.ReadMemStats(&m)
        fmt.Fprintf(w, "ok: cpu=%s  memory=%s MB  alloc=%.1f MB\n",
                cpuStr, memStr, float64(m.Alloc)/1024/1024)
}

func main() {
        // 让调度器线程数 >= CPU 核心数，防止占不满
        runtime.GOMAXPROCS(runtime.NumCPU())

        http.HandleFunc("/query", queryHandler)
        log.Println("listen :8080  e.g.  /query?cpu=2&memory=500")
        log.Fatal(http.ListenAndServe(":8080", nil))
}

go dlv remote debug

Sun, 09 Nov 2025 12:53:24 +0800

总结

这很重要。因为能帮你在本地使用Vscode调试远程服务器上的代码。

实验环境

FROM alpine:latest

# Switch to TUNA mirror for Alpine packages
RUN sed -i 's#https\?://dl-cdn.alpinelinux.org/alpine#https://mirrors.tuna.tsinghua.edu.cn/alpine#g' /etc/apk/repositories

# Install Go and other necessary packages
RUN apk update && apk add --no-cache \
    go \
    git

# Configure Go environment
ENV GOPROXY=https://goproxy.cn,direct

# Install delve (dlv)
RUN go install github.com/go-delve/delve/cmd/dlv@latest

# Add dlv to PATH
ENV PATH=$PATH:/root/go/bin

# Verify installations
RUN go version && which dlv

注意：请保持调试环境中安装dlv的go版本，与编译的go二进制版本，保持一致，如果不一致，将无法调试

dlv --listen=:22345 --headless=true --api-version=2 --accept-multiclient exec ./prac_dlv
API server listening at: [::]:22345
2025-11-09T04:26:11Z warn layer=rpc Listening for remote connections (connections are not authenticated nor encrypted)
To debug executables using DWARFv5 or later Delve must be built with Go version 1.25.0 or later

调试代码

main.go

将断点设置在 a := time.Now() 这一行

package main

import (
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/",func(w http.ResponseWriter, r *http.Request) {
        a := time.Now()
        log.Println("time",time.Since(a))
    })

    log.Println("http://localhost:8080")

    panic(http.ListenAndServe(":8080",nil))
}

编译命令

CGO_ENABLED=0 go build -gcflags "-N -l"

如果不添加 -gcflags "-N -l" ，那么你的调试栈将没有信息。

添加，将有详细调试栈信息

运行镜像

docker run -it -p 8080:8080 -p 22345:22345 alpine-go-dlv

dlv运行

将下面的替换成你的刚二进制可执行文件

 dlv --listen=:22345 --headless=true --api-version=2 --accept-multiclient exec <your_go_bin>

vscode 配置

在你的工作目录下建立 .vscode/launch.json

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "DlvREmote",
            "type": "go",
            "request": "attach",
            "mode": "remote",
            "remotePath": "${workspaceFolder}",
            "port": 22345,
            "host": "127.0.0.1"
        }
    ]
}

Go runtime GOGC

Sun, 09 Nov 2025 00:01:08 +0800

精读，不要贪多，做好笔记，以及完成博客

阅读：

gc-guide

metrics
可以用来做程序的监控，就是如果程度内存的指标太高，就会警告，或者其他量化指标

sa := make([]metrics.Sample,1)
sa[0].Name = "/cpu/classes/gc/total:cpu-seconds"
metrics.Read(sa)

if sa[0].Value.Kind() == metrics.KindBad {
    panic("panic")
}

fmt.Printf("gc : %f \n",sa[0].Value.Float64())

runtime#pkg-overview

runtime#AddCleanup

func main() {
    bufio.NewReader(os.Stdin).ReadBytes('\n')
    for range 20 {
        _ = make([]byte,4<<20)
        //fmt.Println("alloc",i)
    }

    // /cpu/classes/gc/total:cpu-seconds
    sa := make([]metrics.Sample,1)
    sa[0].Name = "/cpu/classes/gc/total:cpu-seconds"
    metrics.Read(sa)

    if sa[0].Value.Kind() == metrics.KindBad {
        panic("panic")
    }

    fmt.Printf("gc : %f \n",sa[0].Value.Float64())

    f,err := os.CreateTemp("/tmp","b")
    if err != nil {
        panic(err)
    }
    f.Close()
    fmt.Printf("f %s\n",f.Name())

    fmt.Printf("add cleanup\n")
    runtime.AddCleanup(f,func(name string) {
        fmt.Printf("\nclearup\n %s \n",name)
        os.Remove(name)
    },f.Name())


    fmt.Printf("gc\n")
    runtime.GC()
    fmt.Printf("gc over\n")
    time.Sleep(100 * time.Millisecond)
    
}

weak#Pointer
不增加对象引用计数
一旦目标被GC回收，指针就变Nil了
runtime#SetFinalizer
建议用AddCleanUp

给一个对象绑定一个最后执行的函数，在被GC回收时，这个函数会被执行
当GC检测到对象无引用时， 1. 清除对象与终结函数的关联 2. 在独立的goroutine中执行绑定的终结函数
runtime.GC
runtime#GC
做垃圾回收，执行会阻塞整个进程，直到垃圾回收完成
pprof#hdr-Profiling_a_Go_program

关联trace，非常重要，用来看作为程序的性能调优依据

为pprof的可视图工具收集运行的数据

go tool pprof --help

GC

内存限制是一个强大的工具，但内存限制并没有代价，也不会使GOGC失效。

gc-guide#Suggested_uses

Latency

一般的GC，stop-the-world

gogc not fully stop-the-world，gogc是并发的。

减少GC频率用以优化延迟。

优秀参考

GC 参考阅读资料 gc-guide#Additional_resources

agent practice

基于gin写一个GC分析教程，让我通过访问哪些接口，看哪些GC数据，以掌握通过GC日志分析代码BUG
我已经定义好了

题解

2025-11-08 22:39:07 终于把Vnote有残影的问题通过Kimi2Turbo Thinking解决了。朋友们，不如直接花钱买Typora，如果乐意HappyHacking，那就是值得的。

pprof里面居然有trace，是我草率了

首先需要将net_pprof配置于程序中

pprof


import (
    _ "net/http/pprof"
)


// 空白引入pprof后，使用http直接Listten，就会将pprof注册到该服务中
func main() {
   go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
   }()
}

使用 localhost:6060/debug/pprof，可查看具体链接

curl 对应的链接，导出
然后使用 go tool pprof --http=:<port> <profile>

curl http://localhost:6060/debug/pprof/heap > heap.profile

go tool pprof --http=:8083 ./heap.profile

通过图，一眼能看出来有问题的代码，泄漏内存。

goroutine泄漏情况，一眼明了

Trace

trace的情况特殊

 curl http://localhost:6060/debug/pprof/trace?seconds=40 -O trace.out

需要使用go tool trace 来预览

 go tool trace -http=:8084 ./trace.out

这真的很牛逼，2025-11-07日帮我在公司一眼定位到代码BUG。

strace追踪Go的net.Listener

Thu, 06 Nov 2025 10:31:39 +0800

总结

就很清晰能看到这样的一个流程

accept4 -> epoll_ctl(ADD) -> epoll_wait() -> read() -> epoll_ctl(DEL) -> close

用strace看net.Listener的Accept函数

目标观察go netpoll中，epoll的使用情况

package main

import (
    "fmt"
    "net"
)

func main() {
    ln, _ := net.Listen("tcp", ":9999")
    defer ln.Close()
    fmt.Println("listen :9999")
    c, err := ln.Accept()
    if err != nil {
        return
    }
    defer c.Close()

    buf := make([]byte, 32)
    n, _ := c.Read(buf)
    fmt.Printf("recv: %s", buf[:n])
}

操作

使用 nc 127.0.0.1 9999 进行通信，得到以下strace日志

strace

strace -f -e trace=%network,%desc -o goepoll.strace ././go_netepoll

10790 <... mmap resumed>)               = 0x75cc70000000
10785 <... fcntl resumed>)              = 0x8002 (flags O_RDWR|O_LARGEFILE)
10785 fcntl(1, F_GETFL)                 = 0x8002 (flags O_RDWR|O_LARGEFILE)
10785 fcntl(2, F_GETFL)                 = 0x8002 (flags O_RDWR|O_LARGEFILE)
10785 socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_TCP) = 3
10785 close(3 <unfinished ...>
10789 mmap(NULL, 262144, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0 <unfinished ...>
10785 <... close resumed>)              = 0
10785 socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_TCP <unfinished ...>
10789 <... mmap resumed>)               = 0x75cc8c848000
10785 <... socket resumed>)             = 3
10785 setsockopt(3, SOL_IPV6, IPV6_V6ONLY, [1], 4) = 0
10785 bind(3, {sa_family=AF_INET6, sin6_port=htons(0), sin6_flowinfo=htonl(0), inet_pton(AF_INET6, "::1", &sin6_addr), sin6_scope_id=0}, 28) = 0
10785 socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_TCP) = 4
10785 setsockopt(4, SOL_IPV6, IPV6_V6ONLY, [0], 4) = 0
10785 bind(4, {sa_family=AF_INET6, sin6_port=htons(0), sin6_flowinfo=htonl(0), inet_pton(AF_INET6, "::ffff:127.0.0.1", &sin6_addr), sin6_scope_id=0}, 28) = 0
10785 close(4)                          = 0
10785 close(3)                          = 0
10785 socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_IP) = 3
10785 setsockopt(3, SOL_IPV6, IPV6_V6ONLY, [0], 4) = 0
10785 openat(AT_FDCWD, "/proc/sys/net/core/somaxconn", O_RDONLY|O_CLOEXEC) = 4
10785 fcntl(4, F_GETFL)                 = 0x8000 (flags O_RDONLY|O_LARGEFILE)
10785 fcntl(4, F_SETFL, O_RDONLY|O_NONBLOCK|O_LARGEFILE) = 0
10785 epoll_create1(EPOLL_CLOEXEC)      = 5
10785 eventfd2(0, EFD_CLOEXEC|EFD_NONBLOCK) = 6
10785 epoll_ctl(5, EPOLL_CTL_ADD, 6, {events=EPOLLIN, data={u32=7379064, u64=7379064}}) = 0
10785 epoll_ctl(5, EPOLL_CTL_ADD, 4, {events=EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET, data={u32=1051721729, u64=8488314593086537729}}) = 0
10786 epoll_pwait(5, [{events=EPOLLIN|EPOLLOUT, data={u32=1051721729, u64=8488314593086537729}}], 128, 0, NULL, 0) = 1
10785 read(4, "4096\n", 65536)          = 5
10785 read(4, "", 65531)                = 0
10785 epoll_ctl(5, EPOLL_CTL_DEL, 4, 0xc00009d924) = 0
10785 close(4)                          = 0
10785 setsockopt(3, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0
10785 bind(3, {sa_family=AF_INET6, sin6_port=htons(9999), sin6_flowinfo=htonl(0), inet_pton(AF_INET6, "::", &sin6_addr), sin6_scope_id=0}, 28) = 0
10785 listen(3, 4096)                   = 0
10785 epoll_ctl(5, EPOLL_CTL_ADD, 3, {events=EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET, data={u32=1051721730, u64=8488314593086537730}}) = 0
10785 getsockname(3, {sa_family=AF_INET6, sin6_port=htons(9999), sin6_flowinfo=htonl(0), inet_pton(AF_INET6, "::", &sin6_addr), sin6_scope_id=0}, [112 => 28]) = 0
10785 write(1, "listen :9999\n", 13)    = 13
10785 accept4(3, 0xc00009dbcc, [112], SOCK_CLOEXEC|SOCK_NONBLOCK) = -1 EAGAIN (Resource temporarily unavailable)
10785 epoll_pwait(5, [], 128, 0, NULL, 0) = 0
10785 epoll_pwait(5, [{events=EPOLLIN, data={u32=1051721730, u64=8488314593086537730}}], 128, -1, NULL, 0) = 1
10785 accept4(3, {sa_family=AF_INET6, sin6_port=htons(33598), sin6_flowinfo=htonl(0), inet_pton(AF_INET6, "::ffff:127.0.0.1", &sin6_addr), sin6_scope_id=0}, [112 => 28], SOCK_CLOEXEC|SOCK_NONBLOCK) = 4
10785 epoll_ctl(5, EPOLL_CTL_ADD, 4, {events=EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET, data={u32=1033371649, u64=8488314593068187649}}) = 0
10785 getsockname(4, {sa_family=AF_INET6, sin6_port=htons(9999), sin6_flowinfo=htonl(0), inet_pton(AF_INET6, "::ffff:127.0.0.1", &sin6_addr), sin6_scope_id=0}, [112 => 28]) = 0
10785 setsockopt(4, SOL_TCP, TCP_NODELAY, [1], 4) = 0
10785 setsockopt(4, SOL_SOCKET, SO_KEEPALIVE, [1], 4) = 0
10785 setsockopt(4, SOL_TCP, TCP_KEEPIDLE, [15], 4) = 0
10785 setsockopt(4, SOL_TCP, TCP_KEEPINTVL, [15], 4) = 0
10785 setsockopt(4, SOL_TCP, TCP_KEEPCNT, [9], 4) = 0
10785 read(4, 0xc00001e0c0, 32)         = -1 EAGAIN (Resource temporarily unavailable)
10785 epoll_pwait(5, [{events=EPOLLOUT, data={u32=1033371649, u64=8488314593068187649}}], 128, 0, NULL, 0) = 1
10785 epoll_pwait(5, [{events=EPOLLIN|EPOLLOUT, data={u32=1033371649, u64=8488314593068187649}}], 128, -1, NULL, 0) = 1
10785 read(4, "asdf\n", 32)             = 5
10785 write(1, "recv: asdf\n", 11)      = 11
10785 epoll_ctl(5, EPOLL_CTL_DEL, 4, 0xc00009dd2c) = 0
10785 close(4)                          = 0
10785 epoll_ctl(5, EPOLL_CTL_DEL, 3, 0xc00009dd44) = 0
10785 close(3)                          = 0

参考：

https://github.com/golang/go/blob/master/src/runtime/netpoll.go

二读《穷查理宝典》

Sat, 26 Apr 2025 20:05:27 +0800

Deepseek写的摘要

摘要：再读《穷查理宝典》的核心启示与实践思考

在重读《穷查理宝典》的过程中，作者深入反思了查理·芒格的智慧体系，提炼出以下核心观点与实践启示：

1. 跨学科思维与长期主义
芒格强调构建多维度知识模型的重要性，认为跨学科积累是投资与决策的基础。其长期主义哲学体现在对优质资产的坚守——以合理价格购买真正价值，而非追逐短期低价。这种理念延伸至生活消费：选择经久耐用的商品，通过“品质成本÷使用年限”实现长期回报，既减少决策负担，又提升生活品质。

2. 逆向思维与群体心理洞察
书中揭示逆向思维的价值：既要避免群体性盲从（如《乌合之众》描述的“群体降智”现象），也需在道德前提下善用心理学规律。芒格对可口可乐成功案例的分析表明，有效产品往往满足深层人性需求（如上瘾机制与情感暗示），但商业实践中应坚守“不卖自己不会买的商品”的底线。

3. 投资哲学与执行策略

核心原则：聚焦简单盈利模式、高利润且诚信的企业，避免高频交易
实践路径：普通人可通过定投标普500/沪深300等指数基金，以被动投资跑赢多数主动管理
决策纪律：重大收益源于少数正确决策，需通过深度调研（如企业现金流折现分析）提高胜率
4. 心理学与处世智慧
芒格系统梳理的25种心理误判（如嫉妒、自怜）成为自我修正的镜鉴。他倡导将心理学既作为防御工具（规避认知陷阱），也作为建设性策略（如销售中的正向暗示），但始终以道德为边界。其处世智慧强调远离低道德群体，通过与优秀者对话实现自我提升。

总结与反思
作者意识到芒格的智慧体系源于数十年的跨学科积累与实践验证，其演讲中平实的建议（如持续学习、耐心等待）背后是深厚的认知复利。书中内容需反复研读，结合实践不断内化——正如芒格所示，真正的成功不在于即时见效的技巧，而在于构建可持续的思维框架与行动纪律。这提示读者：在浮躁时代更需坚守长期主义，相信知识的复利终将在时间维度兑现价值。

再读《穷查理宝典》 2025年04月26日

因为看到老猫在其公众号里更新了一些关系查理芒格的内容。（其实很久之前就看过）

当然，很早这本书我也读过，但过于粗略。这次的阅读其实也过于粗略。

又复习了查理的交易体系，以及对多维度知识模型的重要认识。就是一定要拥有跨学科的知识。这看起来很简单，其实是多年的积累。他的演讲时候已经六七十岁了。他强调自己的是长期主义。

查理是属于那种士大夫的人，他多次提到要远离品德不行的人群。多跟优秀的人交流。最牛逼的一点是，他说要用合理的价格买对应的商品。

因为多数人是想通过更低的价格买到优秀的资产，这显然是在贪小便宜麻。查理的意思就是，如果一个东西值这个价格，即使其降价了，也应该付其值的这个价格。

我也时常因为买便宜的商品，实际上付出了更多的成本。后面坚定的相信长期主义。减少购物的欲望，买的衣服也一定要经久耐用。其实这才是真正兼具品质生活，然后减少心理负担，在价格上，优质的商品除以使用年限，将获得更高的回报，无论是从心理上，体验上，以及品质上。

其一再强调逆向思维。这点我有学到些皮毛。比如其在分析这个大众的心理学的时候，我想到的是，首先我要避免这种无脑式的从众，然后我是不是可以利用这种无脑式的从众来达成自己的目的？当然后者显然不道德，但应该兼具道德的情况下加以利用？这样是可行的。商品在品质与价格到位的情况下，能为用户实际解决问题，那么使用一些心理学的方法，何尝不可？

这里其实很多方面与《乌合之众》《引爆点》有很大相似之处。人在群体之中就会被暗示，以及会降低智商，然后做疯狂之事。比如踩坑。如果商品在群体之中被销售，但如果商品品质到位能解决问题，这其实不算是坑人。但多数，起码是八成的产品肯定是坑人的。

重要一点。在书中讲了查理的投资方式，以及调研方法，心理学

投资方式

不要在市场上赌博
大量赚到的钱来自于几次对的选择，而多数选择会失败
企业如果直接折现，值多少钱
对企业的产品是否足够了解？参考 吉列和可口可乐的逻辑，以及利润。
减少交易的频次（手续费高，其次也会验证自己没有做好准备就上场了，所以非常慌乱
要不断工作，认真工作（或许这是获取现金流有效的方式？）
小结：选择赚钱逻辑简单，利润不错，诚信的企业，然后等待就行。
其实有一个观点就是普通人，无脑定投标普500，就能超过9.5成的基金经理。因为标普500里面多数是优秀企业。同等方式可以换到癌股的沪深300。

调研方法与微观经济学分析方法

感觉很多看这书的人好像并没有意识到其讲的微观经济学，也讲了查理的调研方法。
其有一个观点是，不要卖你自己不会买的商品。
然后就开始分析，为什么可口可乐会流行？因为有咖啡因和糖。然后在非常累的时候，来上一瓶，可以解除些疲劳。其实就是可口可乐会上瘾，但是并没有什么不好的，而且对用户形成暗示，累了应该喝点好喝的汽水。

当然，这很大程度上是因为我们是以结果出发的，会觉得这个事情很简单，可口可乐也有失败的时候。但是

心理学

其中有处世智慧中，最强调的是 不要妒忌，仇恨，自怜，怨憎，这是一种灾难的动物行为。
其用了很长的篇幅介绍了心理学。
后面还重点讲了人类误判心理学，其的心理学知识点显然是让我们去阅读，然后实践的。这并不需要我来总结什么。我从中学习到的是，我如果现实的行为中出现了那25点之中的行为，我应该想办法避免掉这些异常的点，这对自己的有很大的帮助。
但话说回来，这个心理学的分析是不是就是社会之中的漏洞？如果在不损害道德的前提下，是不是可以正确的利用这些漏洞？
现实中是那些销售的礼貌，都说明了你将要踩一个大坑，然后为此长一次记性。

总结这本书我后面大概率会每一年读一两遍。其实并不难懂，当然我也并不是要作什么总结查理的体系。这本书至少要读个十几遍才行。或许是因为之前读过一遍，有一些实践，所以这一遍才能发现简单话语之中的奥妙。

他的随和告诉我，要耐心等待，要大量的阅读，不断的学习，即使非专业也能做到利用其他学科的知识来扩展自己的思维格局。还有一点就是要等待。因为这些演讲并不是在他二十多岁写的，而在六十多岁后，慢慢有成就的时候写的。这说明其在我们不知晓的岁月里做了大量的积累。

无他，静待就好。希望知识终将有用到的那一日。

咏梁子湖

Sun, 02 Mar 2025 19:01:37 +0800

三日不见已是昨天，长夜漫漫非尔独行。
山川日月积非几秋，忽觉了书房往事迹。
望大山大湖开心阔，也非了史书情节事。
弓身做了骑行者间，沉寂岁月待有孤篇。

2025年许愿

Sun, 16 Feb 2025 21:50:24 +0800

搞Rust，基于rust写个好玩的项目
玩emacs，基于原生的emacs的思维，重新配置一套极简的emacs配置
明朝那些事儿
体重-20斤
写5篇技术博客
初步深入学习linux操作系统

既然是许愿，那么没完成也无所谓了。
不过好消息是，2024年的许愿，有个七八成许愿实现了。

Stylus 修改打开网站的文本样式，将所有网页文本改成宋体

Sun, 29 Dec 2024 18:39:12 +0800

宋体是一个比较成熟的字体。这么做，主要还是因为我近年发现，微软雅黑的字体，明显修改了一些字体的结构，导致我们与学习的中文明显对不上型，然后就会突然发现一些字，明显不长这样。

长时间习惯看微软雅黑会降低识字率和增加错字率。从教育书本方面，基本统一宋体。所以非常推荐将系统默认字体，所有阅读相关的字体改成宋体。

楷体也很不错，入门书法都是练的楷体，本人也练了四五年楷体，作为手写体非常推荐。（主推颜体）

*:not([class*="icon"]):not(i) {
    font-family: "SimSun", serif !important;
}