本機快速架一個 Nginx load balancer + 多個 backend，用來測試分流。

lb/nginx.conf
server/Dockerfile
docker-compose.yml

Backend

FROM python:3.12
CMD ["python3", "-m", "http.server", "8080"]
EXPOSE 8080

Nginx

events {}

http {
    upstream backend {
        server server1:8080;
        server server2:8080;
        server server3:8080;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
        }
    }
}

• upstream 預設 round-robin；可加 least_conn、ip_hash 或 weight=
• compose 內用 service 名稱當 hostname

docker-compose.yml

services:
  lb:
    image: nginx
    volumes:
      - ./lb/nginx.conf:/etc/nginx/nginx.conf:ro
    ports:
      - 8080:80
    depends_on: [server1, server2, server3]
  server1:
    build: server/
  server2:
    build: server/
  server3:
    build: server/

測試分流時 client / server 都用 async，並在 backend 記 log 再統計。

參考

• 原文：Docker-compose + Nginx as Load Balancer
• Docker network 模型

需求：把不在 apt repo 的 Go 工具穩定地打包成 .deb（例如裝到 /opt/<org>/<tool>/bin）。

選項

C/C++ 這類來源不穩、需要後處理（submodule）的套件，才比較適合 zip + CMake 的做法。

需要離線 / 防止依賴消失時，也可以考慮 Go module proxy（例如 Athens）當 read-through cache。

參考

• 原文：穩定打包 Go Binary 成 Debian Package 的選擇
• Debian Go Packaging

產生 patch

diff -Naur old new > patch.diff

• -N：不存在的檔案視為空檔，patch 才能新增 / 刪除檔案
• -a：binary 也當文字比
• -u：unified format，沒有的話 patch 無法解析
• -r：遞迴資料夾

套用 / 還原

patch -p0 < patch.diff      # old → new
patch -p0 -R < patch.diff   # new → old

-pN：去掉 patch 內路徑前 N 層。

參考

• 原文：Linux command: Diff/Patch
• diff(1)、patch(1)

記憶體不足時，kernel 用 oom_badness()（mm/oom_kill.c）替每個 process 打分數，分數最高的被 kill。

不列入候選

• kthread 等 unkillable task
• 正在 vfork
• oom_score_adj 為 OOM_SCORE_ADJ_MIN（-1000）
• 已被 OOM reap / 標記 MMF_OOM_SKIP

分數

points = rss + swap + pagetable_bytes / PAGE_SIZE;
points += oom_score_adj * totalpages / 1000;

• 基準是 process 佔用的記憶體（RSS、swap、page table）
• oom_score_adj（-1000 ~ 1000）可手動調整：/proc/<pid>/oom_score_adj
• 目前分數：/proc/<pid>/oom_score

參考

• 原文：OOM Killer 簡短筆記
• How does the OOM killer decide which process to kill first?
• Out-of-memory victim selection with BPF

fcntl 提供跨 process 的 read/write file lock，但 lock 屬於 process，不屬於 thread 或 fd。

坑：同一 process 不能跨 thread 共用

If a process closes any file descriptor referring to a file, then all of the process's locks on that file are released, regardless of the file descriptor(s) on which the locks were obtained.

• Thread 1、Thread 2 都對 mydata.lock 上 read lock
• 其中一個 unlock 或 close fd → 整個 process 失去這把 lock
• 另一個 thread 以為自己還持有，實際上已經沒有保護

解法

• 每個 thread 用不同的 lock 檔（拆成多把 lock）
• 或在 process 內另外用 mutex / 計數管理，只由一個地方持有 fcntl lock
• Linux 3.15+ 可考慮 OFD lock（F_OFD_SETLK），lock 綁在 open file description 上

參考

• 原文：Linux fcntl Filelock 中的小坑：在同一 Process 不能跨 Thread 使用
• fcntl(2)

Thread 也是 process

Linux 排程時每個 thread 都有自己的 tid（gettid()），kill -s SIG <tid> 會讓該 thread 執行 signal handler。

pthread_kill

• 在 process 內對指定 thread 送 signal
• 被 signal 打斷的 sleep 等 blocking call 會提早返回

pthread_cancel

• 只在 cancellation point（大多是 IO、sleep 等 blocking call）中斷 thread
• glibc 實作：對目標 thread 送 signal → handler 呼叫 __do_cancel → __pthread_unwind → _Unwind_ForcedUnwind
• 因為是 forced unwind，glibc 下 C++ destructor 會被呼叫；macOS（Apple clang）實測不會
• 行為不在標準內，跨平台不要依賴，一般也不建議用 pthread_cancel

參考

• 原文：pthread_cancel 與解構子行為實驗、pthread_kill 實驗
• pthread_cancel(3)、pthread_kill(3)
• pthread_cancel considered harmful

新檔案拿不到 group write

open(path, O_CREAT, 0664) 實際權限是 mode & ~umask，預設 umask 022 會關掉 group write。

解法：

• Default ACL（推薦）：對資料夾設定，之後新建的檔案都會繼承

  bash

  setfacl -d -m g:myteam:rwx <dir>
  getfacl <dir>

• umask(002)：process 層級，不是 thread-safe，暫時改再改回去會有 race

• 建立後再 chmod：中間有時間差

Git：unsafe repository

Git 2.35.2 起（CVE-2022-24765），repo owner 不是目前使用者時，連 git log 都會拒絕：

fatal: unsafe repository ('/path/to/repo' is owned by someone else)

信任該路徑：

git config --global --add safe.directory /path/to/repo

沒有 group 層級的設定。

參考

• 原文：一個 Group Write Permission 的坑、Git Repository 限制使用者存取
• git-config: safe.directory

C++ 用 destructor 自動釋放資源（RAII），但 class 持有 raw pointer 時，只寫 constructor / destructor 不夠。

Rule of Five

編譯器自動生成的 copy 只複製指標 → 兩個物件指向同一塊記憶體 → double free。

Copy：copy-and-swap

IntBuff& operator=(const IntBuff& ib) {
    IntBuff tmp(ib);          // 可能 throw 的部分先做
    std::swap(arr, tmp.arr);  // 不會 throw 才改自己
    std::swap(sz, tmp.sz);
    return *this;
}

順便處理了 self-assignment 與 exception safety。

Move

• r-value：只能放在等號右邊的值，例如 foo()、b + 1、99
• T&& 綁定 r-value；std::move(x) 把 l-value 轉成 r-value reference
• 實作 move：接手指標，並把來源設成「空」，避免重複釋放

IntBuff(IntBuff&& ib) noexcept : arr(ib.arr), sz(ib.sz) {
    ib.arr = nullptr;
    ib.sz = 0;
}

std::unique_ptr

一個 class 管理一個資源。成員改成 std::unique_ptr<int[]> 後：

• 不用手寫 delete
• move 直接 = default
• copy 被禁止，需要時自己實作（new 一份再複製內容）

class IntBuff {
public:
    explicit IntBuff(size_t sz) : arr(std::make_unique<int[]>(sz)), sz(sz) {}
    IntBuff(const IntBuff& ib) : IntBuff(ib.sz) {
        std::copy(ib.arr.get(), ib.arr.get() + sz, arr.get());
    }
    IntBuff& operator=(const IntBuff& ib) {
        IntBuff tmp(ib);
        std::swap(*this, tmp);
        return *this;
    }
    IntBuff(IntBuff&&) noexcept = default;
    IntBuff& operator=(IntBuff&&) noexcept = default;

private:
    std::unique_ptr<int[]> arr;
    size_t sz = 0;
};

參考

• 原文：1. Copy Constructor、2. Move、3. std::unique_ptr

目標：離開 scope 時自動 fclose。

std::unique_ptr + deleter

std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(path, "r"), &fclose);
if (!fp) { /* 開檔失敗 */ }

• 型別是 FILE 不是 FILE*
• unique_ptr 為空時不會呼叫 deleter，fopen 失敗也安全

自製 Defer

struct Defer {
    template <typename F>
    explicit Defer(F&& f) : func_(std::forward<F>(f)) {}
    ~Defer() { func_(); }

    Defer(const Defer&) = delete;
    Defer& operator=(const Defer&) = delete;

private:
    std::function<void()> func_;
};

Defer d([&] { fclose(fp); });

std::function 可以吃 lambda、std::bind、function pointer。

參考

• 原文：Way to C++: 4. Auto close (雜)

new 失敗會 throw，下面的 arr1 就 leak 了：

int* arr1 = new int[n];
int* arr2 = new int[n];  // throw → arr1 沒被釋放

解法：每個資源交給一個 RAII 物件（std::unique_ptr、std::vector…），不要逐個 try-catch。

等級

越強成本通常越高。

技巧

• copy-and-swap：先做可能 throw 的 copy，再用不會 throw 的 swap 修改自己 → strong guarantee
• move constructor / swap 盡量標 noexcept，std::vector 擴容時才會用 move 而不是 copy

參考

• 原文：Way to C++: 6. Exception Safe、3. std::unique_ptr

想寫一個 wrapper，把參數原封不動（l-value / r-value）轉給 foo：

template <typename T>
void callFoo(T&& val) {          // forwarding reference
    foo(std::forward<T>(val));   // 保留 value category
}

• 只有在 template 型別推導 時，T&& 才是 forwarding reference；int&& 就只是 r-value reference
• 推導：傳 l-value → T = U&，傳 r-value → T = U
• 有名字的變數一律是 l-value，所以直接 foo(val) 永遠呼叫 l-value 版本，需要 std::forward<T>

參考

• 原文：Way to C++: 5. Forwarding Reference

CPU 以 word 為單位讀取，變數的起始位置通常是自身大小的倍數，否則可能要讀兩個 word。

Struct 規則

• alignment = 最寬成員的 alignment
• 成員之間補 padding 以滿足各自的 alignment
• 尾端補 padding，讓 sizeof 是 alignment 的倍數（當作陣列時仍對齊）
• padding 的內容不保證是 0

struct bar {       // sizeof = 24
    char c;        // 1 + 7 padding
    uint64_t v1;   // 8
    uint16_t v2;   // 2 + 6 padding
};

struct bar2 {      // sizeof = 16
    uint64_t v1;
    uint16_t v2;
    char c;        // 尾端 5 padding
};

減少 padding

• 由大到小排列成員；代價是可讀性，以及相關欄位分開可能影響 cache
• __attribute__((packed))：完全不補 padding，存取可能變慢或在某些架構上出錯

檢查

• sizeof(T)、offsetof(T, member)、alignof(T)
• Go 不支援 packed struct，cgo 需注意（cgo wiki）

參考

• 原文：C/C++ Memory Alignment
• The Lost Art of Structure Packing

用「多型 + 模板」把任意型別包成同一個型別，也就是 std::function 的做法。

結構

struct CallableBase {                     // 1. 抽象介面
    virtual ~CallableBase() = default;
    virtual void call() = 0;
    virtual std::unique_ptr<CallableBase> clone() const = 0;
};

template <typename F>
struct CallableImpl : CallableBase {      // 2. 模板實作，記住真正的型別
    F f;
    explicit CallableImpl(F f) : f(std::move(f)) {}
    void call() override { f(); }
    std::unique_ptr<CallableBase> clone() const override {
        return std::make_unique<CallableImpl>(*this);
    }
};

class Callable {                          // 3. 對外的值型別
public:
    template <typename F,
              typename = std::enable_if_t<!std::is_same_v<std::decay_t<F>, Callable>>>
    Callable(F f) : p_(std::make_unique<CallableImpl<F>>(std::move(f))) {}
    Callable(const Callable& o) : p_(o.p_ ? o.p_->clone() : nullptr) {}
    Callable& operator=(const Callable& o) {
        Callable tmp(o);
        p_.swap(tmp.p_);
        return *this;
    }
    Callable(Callable&&) = default;
    Callable& operator=(Callable&&) = default;
    void operator()() { if (p_) p_->call(); }

private:
    std::unique_ptr<CallableBase> p_;
};

重點

• 比起直接 template <typename F> void foo(F)，型別錯誤會在呼叫端就報出來
• unique_ptr 不能 copy → 需要 virtual clone()
• 模板 constructor 要排除 Callable 自己，否則 copy 非 const 物件會優先匹配模板，包成 CallableImpl<Callable> 並無限遞迴
• 進一步：支援 Callable<R(Args...)> 簽名

參考

• 原文：簡介 C++ 的 Type Erase (用多型和模板做 Duck Type)

在 member function 裡拿到自己的 shared_ptr / weak_ptr。

錯誤做法

std::shared_ptr<Foo>(this) 會建立另一組 control block → 同一物件被 delete 兩次。

用法

1. public 繼承 std::enable_shared_from_this<T>
2. 呼叫 shared_from_this() 或 weak_from_this()（C++17）

原理：shared_ptr 建構時偵測到這個 base，就把自己存進其中的 weak_ptr。

坑

物件不是由 shared_ptr 管理時，shared_from_this() 會 throw std::bad_weak_ptr。

→ constructor 設 private，只提供 factory：

class Node : public std::enable_shared_from_this<Node> {
public:
    static std::shared_ptr<Node> create() {
        return std::shared_ptr<Node>(new Node());
    }

    void setLeft(std::shared_ptr<Node> node) {
        left_ = node;
        left_->parent_ = weak_from_this();  // parent 用 weak_ptr 避免循環
    }

private:
    Node() = default;
    std::weak_ptr<Node> parent_;
    std::shared_ptr<Node> left_;
};

參考

• 原文：取得自己的 shared pointer
• cppreference: enable_shared_from_this

errno 的正確用法

• 函數不會清掉 errno
• 只有函數回報失敗時（回傳 NULL、-1 等，看文件），errno 才有意義

// ❌ 成功時 errno 也可能非 0（內部 open 時區檔失敗但有 fallback）
errno = 0;
gmtime_r(&t, &tm);
if (errno) perror("gmtime_r");

// ✅
if (!gmtime_r(&t, &tm)) perror("gmtime_r");

gmtime_r 的效能

• gmtime_r 與 localtime_r 共用實作，會呼叫 tzset_internal 讀時區設定並更新全域狀態
• thread-safe 是靠 lock → 多 thread 頻繁呼叫時大量時間花在 kernel mode
• 高頻呼叫可以考慮自己算，或用 Boost Posix Time、C++20 <chrono>

參考

• 原文：C Error Handling: errno、gmtime_r 使用性?
• gmtime source

陣列參數會退化成指標

void f1(char a[20]);            // 其實是 char*，sizeof(a) == 8
void f2(char (&a)[10]);         // reference，sizeof(a) == 10，只收長度 10
template <size_t N>
void f3(char (&a)[N]);          // reference + 推導，任意長度都正確

要保留長度：用 array reference + template，或改用 std::array / std::span。

不建構物件取得成員大小

sizeof(Foo::m);             // C++11
sizeof(((Foo*)0)->m);       // C 寫法：sizeof 不會真的 evaluate

參考

• 原文：sizeof array、Size of a non-static member of a class
• N2253

std::string_view 用 傳值 就好，不需要 const std::string_view&。

• 語意上它本來就是 view（reference）
• 只有指標 + 長度，傳值時 x86-64 直接放進兩個暫存器
• 傳 const& 反而要先在 stack 建立物件再傳位址（gcc -O3 實測指令更多）

小型 trivially copyable struct 同理。

參考

• 原文：std::string_view 函數傳值與編譯器最佳化
• Three reasons to pass std::string_view by value

倒序迴圈

size_t 是 unsigned，i >= 0 永遠成立 → 無窮迴圈：

for (size_t i = n - 1; i >= 0; --i)  // ❌
for (size_t i = n; i--;)             // ✅ 但不好讀

換成有號型別時：

偏好 std::ptrdiff_t（標準、可移植）。

int64_t literal

1L、1LL 都不是跨平台的 int64_t（int64_t 在 macOS 是 long long、Linux 是 long），std::min(1L, a) 會因型別不同編不過。

• ✅ static_cast<int64_t>(1)
• ✅ 有意義的常數：const int64_t kMin = 1;
• ❌ INT64_C(1)：型別是 int_least64_t，不保證就是 int64_t

參考

• 原文：C++ 中倒序存取陣列的型別問題、int64_t Literal Constant?

C++ 中 沒有 side effect 的無窮迴圈是 UB，編譯器可以假設迴圈會結束。

int main() {
    while (1);
}
void unreachable() { std::cout << "why?\n"; }

clang 15 -O1 會把 main 整個刪掉，直接落到下一個函數，印出 why?。

同理，下面的 Collatz 迴圈會被編成單一 ret，不是編譯器證明了猜想：

void collatz(unsigned n) {
    while (n > 1) n = n % 2 ? 3 * n + 1 : n / 2;
}

• C++26（P2809）起，條件為常數的 trivial 無窮迴圈（如 while (1);）不再是 UB
• gcc、MSVC、clang 11、-O0 都不會這樣
• 需要無窮等待時，迴圈內放 side effect（I/O、volatile、atomic），或改用 sleep / 條件變數

參考

• 原文：C++ 有關迴圈的未定義行為？

匯出 EPub

1. 把要會出的書籍拖出來（例如拖到桌面）。此時拖出來的東西雖然雙擊後可以從 iBooks 打開，但其實仍然是一個資料夾。

2. 把這個資料夾壓縮成 zip 。

2. 把 .zip 副檔名去掉，就可以拿到 Epub 檔案了。