Ti7000 之前掉盘了，朋友的 PC005 自己用了帮别人装，一年多了没出过问题

@lxdlam 没有换行写的有点乱，最后一条 case 和 default 是不同的分支

Reading Material： https://go.dev/blog/pipelines

拆成两个问题：
1. 多个 goroutine 如何读取消息
- 使用 fan-in 和 fan-out pattern ，将其结果汇总到一个 channel 里，此时原始 goroutine 关闭 channel 不影响；
- 直接 select 多个 channel 。
2. 当某个 gorutine 退出时如何通知其他的 goroutine 退出：
a. （可选）如果需要等待其他 goroutine 退出的话，使用 sync.WaitGroup 等待；
b. 使用一个 exitChannel （ chan struct{} 就行），接收到退出信号的时候直接由 main close ，其他 goroutine 使用 `for { select { case <- exitChannel: return default: logic} }` 的形式来正确接受退出信号

尾递归跟迭代没有任何直接联系。

- 可以把尾递归优化成迭代并不意味着常规递归不能被优化成迭代： https://stackoverflow.com/questions/54686395/how-can-modern-compiler-optimization-convert-recursion-into-returning-a-constant 。
- 可以把尾递归优化成迭代同样不意味着尾递归一定会被优化成迭代： http://neopythonic.blogspot.com/2009/04/final-words-on-tail-calls.html

- `shared_ptr<T>` 的结构由两部分组成：control block 和 data block ，其中 control block 负责控制引用计数，并发安全，但是 data block 无任何并发安全保证。
- `shared_ptr<T>::unique()` 负责检查是否仅有一个用户在使用（即自己）。

所以这是一个比较简单的 CoW(Copy-oon-Write) pattern ，在需要修改时复制一份数据单独维护。

这个其实是一个很常见的策略，很多时候 pivoting 用到的知名工具都会被标记有风险，比如 frp ，chisel 等等

@bmpidev2019 废弃的原因其实是因为 Linux 的线程实现方式的历史原因。https://web.archive.org/web/20040211225937/http://java.sun.com/developer/technicalArticles/Programming/linux/

注意到：
> ... Each Linux thread is created as a process clone operation, which leaves the scheduling of threads to be a task of the process scheduler.

而彼时的 Linux 内核版本离 2003 年真正实现了内核态的抢占调度（ 2.6 版本，CFS 算法）还有 3 年，也就是说，这个时候的 Linux 只支持一个时间一个线程在跑，OS 无法主动抢占当前正在执行的线程，必须由用户侧程序来调用 schedule 。换句话说，这个时候创建的线程受到了 Linux Process Scheduler 的制约（ Linux Scheduler 调度的最小单元是 Thread ），无法实现真正的并行（操作系统无法调度到其他 CPU 上），同时，这样实现的 Thread 切换跟 OS Thread 切换是一致的，也受到 OS Thread 切换的制约（ Context Switch ，内核态-用户态进出）。

> By comparison, on Solaris the Java threads are mapped onto user threads, which in turn are run on Lightweight processes (LWP). On Windows the threads are created inside the process itself. For this reason, creating a large number of Java threads on Solaris and Windows today is faster than on Linux. This means you might need to adjust programs that rely on platform-specific timing to take a little longer on startup when they run on Linux.

正如你文章引用的 Solaris 调度系统图所说，Solaris 的调度存在 LWP 这个中间单元，这个中间单元其实类比于现在并发的 M:N 实现，实际是比较超前的。LWP 能被自由的调度到多个 Kernel Thread 上，多个 Kernel Thread 也可以被自由地调度到每个 CPU Core 上；而 Windows 的调度也是在 Process 的树形结构下调度的。在这两个系统下，由 JVM 实现的调度器能够自由地把 Task 进行低开销地切换（要么发生在 LWP 间，要么发生在 Process 内），系统调度的时候也不仅仅以 Thread 为单位（ LWP-Kernel Thread 或者 Process-Thread ），使得在这两个平台上，Green Thread 的调度都是合理的。

当然，随着后面 Linux 的崛起，Java 1.3 虽然放弃了 Green Thread 实现，但是 Project Loom 又把它带回来了，这也是 OpenJDK 认为的，Java 并发调用的未来。

@lxdlam 好像记忆出现了偏差，Project Loom 应该是 cooperative 的。

仍然是有问题的哈。

1. Go 的 Goroutine 在 1.14 之后就是基于信号抢占式调度的了（ https://go.dev/doc/go1.14 ），因为没有手动的 yield ，并不是 cooperative 的。
2. Java 的 Green Thread 已经在 1.3 之后被 Native Thread 取代，换句话说，现行的 JDK 的原生调度模型等同于 OS Thread 。Java 的新用户侧线程 Project Loom 会是新的 Green Thread 方案，但是仍然是抢占式调度的。
3. 由于硬件和软件的进步，Windows 的 Fibers 已经日渐式微了（ https://devblogs.microsoft.com/oldnewthing/20191011-00/?p=102989 ），在日常讨论中常用的 User-Thread 切换已经基本达到一样的性能。
4. 抢占式调度和协作式调度的核心区别不是有新任务时是谁在执行，而是谁发出切换信号：抢占式调度往往在一些重要位置（ sleep call ，timer tick ）放置了中断信号，通过这个信号通知 scheduler 进行切换；协作式调度则是通过 thread 自己根据执行情况，主动交出控制权。

@FrankHB 说得很好，感谢！昨天回复的比较着急，今天来看很多地方说的确实是不够准确的，关于 C 的部分我的本意其实是说纯文本替换并没有 type level 的工作，所以不算泛型，最后没写清楚。

Mario Strikers 是系列第三作了，第一作 2005 NGC ，第二作 2007 Wii ，这次是暌违 15 年的新作。