博客更新：从 zine 到 Zola

2026-07-17T00:00:00+00:00

时间过得真快，转眼我已经工作近两年了（我现在做的事情离代码很远），再次打开博客一看，上一篇文章还停在 2023 年 5 月的《xv6 学习记录》。

最近重新动了写博客的念头，索性先把房子翻新一遍：把博客从 zine 迁移到了 Zola。这篇就当作迁移记录，也算是重新开张的第一篇。

从 Happened-before 说起（1）

2023-03-22T00:00:00+00:00

本文大部分是背景介绍，本来想一气呵成，但发现要讲的东西有点多，遂分成了两篇来写。 </blockquote>
Mara Bos</a> 关于并发主题的新书 Rust Atomics and Locks</a> 最近可以免费在线阅读了，这位 Rust Library team 的 Leader 自不必多说，对 Rust 的理解（贡献）非是常人可比，而这次 Mara 博士这次的慷慨更是让手头常年拮据学生党（鄙人）直呼老铁 666！~~耶，是官方的白嫖！</del>~~
玩笑差不多了，说正事。
尽管鄙人的英语是中国人水平，但为了学点 Rust，困难可以克服（感谢谷歌翻译+DeepL+ChatGPT），这本书不长，但想要读透，真正领会作者的思想，要花好多功夫。在一众翻译软件的帮助下，我简单阅读了这本书的前几章内容，其中第一个令我印象深刻的内容当属第 3 章中提到的也是我们今天的主题：Happened-before 关系。
要讨论 Happened-before 关系，说来话长，让我们保持耐心，先从简单的计算机历史说起。
最初的计算机工作非常简单，只要把一些简单繁琐的计算任务搞定即可，在真空管和穿孔打卡的时代，程序员是把程序写到纸上，你没看错，是纸，然后在纸上穿孔，如此反复操作，直到穿成厚厚的一摞，再把这一摞交给计算机，计算机计算结果打印出来，然后程序员拿到打印结果。

这就是最开始的 IO。 </blockquote>
用今天的眼光看那时的程序员也太不容易了，纸上编程确实有助于学习编码和思考代码逻辑，但如果真要把干活的程序写在纸上再去穿孔才能执行，这种繁琐、浪费是现在的程序员所无法想象的（谁愿意天天穿孔），你可能会问：如果我就运行自己的程序行不行，答案是不行！在当时计算机的资源是相当昂贵的，没有那么多机器让你一个人玩，就像买东西太贵选择拼单一样，你写程序也要和人拼计算机，所谓批处理就是这么一回事，名字起得挺高深，实际上背后一把辛酸泪。
这样的 IO 用脚趾头想都能想到肯定会和 CPU 的速度存在巨大差异，CPU 的计算时间非常少而等待 IO 结束的时间却很多。所以为了让 CPU 更累</del> 更合理地利用 CPU 计算资源，我们就得想个办法，看能不能「偷」点时间出来。后来不知道哪位天使大哥/大姐想到了一个鬼点子：我们可以把内存划分为多个部分（日子宽裕了，内存也比以前大了，可以让更多程序用了），不同的程序可以使用各自的内存部分互不干涉，这些单独的程序就是所谓的进程。然后我们给 CPU 再加上一个超能力：跨进程切换执行。这样就有戏法可以玩了：当某个进程进行磁盘 IO 的时候，CPU 就可以切换到另外一个进程执行（闲着也是闲着，不如干点别的活），这样就 ~~让 CPU 更累</del> 偷出了本来可以摸鱼（等待 IO）的时间来干活（运行其他进程），我们的目的达到了！（能力越大，责任就越大嘛~）~~
怎么给 CPU 加上跨进程切换执行的超能力呢？请看三板斧：

CPU 时间片：现在我们有很多进程，所以对于每个进程如何执行，需要有个规定──每一次切换进程后，CPU 只会工作一段时间，然后又切换到另外一个进程，再执行一段时间。我们把 CPU 切换进程的这个时间段叫做“时间片”。</li>
程序计数器：CPU 经过一圈切换后还会切换回最开始的进程继续执行（对每个进程都是如此），所以它需要知道进程已经执行到了哪一步才好接着执行，程序计数器应运而生，它会记住进程执行到的位置。有了这个就可以继续执行了。</li>
栈指针：程序计数器解决了记忆程序（代码）执行到的位置，但是每个进程还持有操作系统分配给它的内存资源，这玩意对每个进程是独立的，因此也需要记录，所以我们用栈指针来记录操作系统给它的内存资源地址。</li> </ul>
这三板斧下去，CPU 再也不好摸鱼了，比起以前，那效率是高多了，但是人类对于极致的追求是无止境的，大家慢慢发现切换进程这个操作本身居然挺费时间，如果每个进程都有很多 IO，那么 CPU 的时间都被切换进程浪费掉了，然后还什么都没做，这不是又让 CPU 闲着了吗？不行，必须要解决！

这只是一个缺点，相关的缺点还有很多，不一一列举了。 </blockquote>
进程切换成本这么高，一部分的原因是进程太「重」了，每切换一次上面的三板斧都得顾及到，那么让它变得小一点不就好了吗？这就是线程：我们让一个进程创建很多个线程，然后让线程来做以前进程的工作，现在 CPU 会在线程而不是进程之间来回切换，由于线程更小，时间片也分得更小，以至于多个线程之间切换执行成本也小了，同时 CPU 等待 IO 的几率也更加小了。一举多得。

线程版本的三板斧：

程序计数器，表示当前线程执行指令的位置。</li>
保存变量的寄存器。</li>
栈。每个线程的栈记录了函数调用的记录，并反映了当前线程的执行点。</li> </ul> </blockquote>
技术领域有一句名言：没有银弹。意思是不管什么问题，没有万能解决方案。多线程也不是没缺点，对程序员来说最直观的感受就是：多线程编程更难。为什么？因为在多线程编程的场景下，你会经常遇到「多个线程同时读取和修改同一个变量」的问题，而在 Rust 中，我们认为“这通常会导致未定义的行为（UB）”。
为什么“多个线程同时读取和修改同一个变量”会是个问题？这不是效率更高了吗？请看下面的伪代码：
data_race() { global x = 0 thread1 = thread { for i in 0..100 { x += 1; } }; thread2 = thread { for i in 0..100 { x += 1; } }; t1 = thread1.spawn(); t2 = thread2.spawn(); t1.join(); t2.join(); return x; }</code></pre>

之所以写伪代码是因为用 Rust 想写个有问题的程序着实不容易。 </blockquote>
伪代码说明（虽然我希望这是不言自明的）：

global x = 0</code> 表示 x</code> 是个全局变量，每个线程都能看到并修改它的值</li>
thread1 = thread { for i in 0..100 { x += 1; } };</code> 表示 thread1</code> 对 x</code> 进行 100 次加 1 操作，这是 thread1</code> 的定义</li>
t1 = thread1.spawn();</code> 则是启动 thread1</code>，thread1</code> 自此开始执行</li>
thread1.join();</code> 表示当前线程（主线程）将一直等待 thread1</code> 执行结束</li>
thread2</code> 上述一切同理</li> </ul> 请猜想下，这段程序执行到 return x;</code> 时，x</code> 的值会是多少？ 答案是：只有天知道，理论上在 100-200 之间的任何整数值都有可能。 你可能会问：x</code> 不是 200</code> 吗？ x</code> 不一定会是 200</code>，这就是多线程编程的吊诡之处，很反直觉。 更反直觉的还在后面。 </blockquote> 试想下面的过程：（1）CPU 时间片先分给 thread1</code> 执行，假设代表 x</code> 这个变量的寄存器在 thread1</code> 中执行累加到了 50，此时恰巧时间片用完了，而存放在寄存器中的值 50 还没来及写入实际的物理内存。（2）因为时间片用完了，CPU 现在分配给 thread2</code>，由于 thread1</code> 算出来的值并没有写回内存，所以实际上此时 thread2</code> 还是从 x = 0</code> 开始进行加 1 操作，这次我们假设分给它的时间片够进行 60 次加 1 操作，之后 thread2</code> 将得到的 x = 60</code> 写入实际的物理内存。（3）时间片再度分配给 thread1</code>，thread1</code> 开始执行它在上一个时间片结束时没有执行完的工作，将 x = 50</code> 写入实际的物理内存，计算机严格按照代码执行指令，但此时问题出现：thread1</code> 计算并写入的 x = 50</code> 会把 thread2</code> 计算并写入的 x = 60</code> 覆盖掉。而每次执行程序，上述情况的发生总不会完全一致，比如时间片的大小就不是能完全确定的，相当于每次都有微调，这就是多次执行相同的代码得到的结果却完全不一致的原因。 其实真实的过程比这复杂得多，这里进行了简化以方便讨论概念。 </blockquote> 如何解决这样的问题？先来看问题出在哪里。我们可以发现上面程序过程中的关键点是：每个线程的计算 x</code> 的值 和把算好的值存入物理内存 这两个操作之间是不连续的，这样就给了其他线程进来搞破坏的可趁之机。如果在单个线程中，计算值和把算好的值存入内存这两个操作连续进行是很自然的，自然到你根本不会意识到它们还可以不连续，这是你编程时的默认心智模型，如果这一条都不成立大家也就不用编码了。 其实这里面还有指令重排的事，别以为你「看到」的就是「真相」。 </blockquote> 但是在多线程环境中，这就成为了问题，为了灵活和性能，多线程编程的自由度更高。如果多线程编程要强行规定线程间的执行顺序、线程内的指令执行顺序，那样还有意义吗？还不如继续优化多进程。 好，我们现在遇到了一个“既要…还要…”的问题：我们既要留住多线程的灵活，又要让它在某些时候不那么灵活，有没有两全法呢？有，原子操作！ 原子操作是什么呢？我认为最通俗易懂的说法是：要么不做，要么全做。不过我的总结不够规范，咱们还是来看专业人士（Mara Bos 博士）是怎么表述这个概念的： The word atomic comes from the Greek word ἄτομος, meaning indivisible, something that cannot be cut into smaller pieces. In computer science, it is used to describe an operation that is indivisible: it is either fully completed, or it didn’t happen yet. 原子这个词来自希腊语 ἄτομος，意思是不可分割的，不能被切割成更小的部分。在计算机科学中，它被用来描述一个不可分割的操作：它要么完全完成，要么还没有发生。 However, atomic operations do allow for different threads to safely read and modify the same variable. Since such an operation is indivisible, it either happens completely before or completely after another operation, avoiding undefined behavior. 原子操作允许不同的线程安全地读取和修改同一个变量。由于原子操作是不可分割的，它要么完全发生在另一个操作之前，要么完全发生在另一个操作之后，这样就避免了 UB。 Atomic operations are the main building block for anything involving multiple threads. All the other concurrency primitives, such as mutexes and condition variables, are implemented using atomic operations. 原子操作是涉及多线程的任何事物的主要构建块。所有其他并发原语，例如互斥量和条件变量，都是使用原子操作实现的。 In Rust, atomic operations are available as methods on the standard atomic types that live in std::sync::atomic</code>. They all have names starting with Atomic</code>, such as AtomicI32</code> or AtomicUsize</code>. Which ones are available depends on the hardware architecture and sometimes operating system, but almost all platforms provide at least all atomic types up to the size of a pointer. 在 Rust 中，原子操作可以作为存在于 std::sync::atomic</code> 中的标准原子类型的方法。它们的名称都以 Atomic</code> 开头，例如 AtomicI32</code> 或 AtomicUsize</code>。哪些可用取决于硬件架构，有时取决于操作系统，但几乎所有平台都至少提供所有原子类型，最大为指针大小。 Unlike most types, they allow modification through a shared reference (e.g., &AtomicU8</code>). This is possible thanks to interior mutability, as discussed in “Interior Mutability” in Chapter 1. 与大多数类型不同，它们允许通过共享引用进行修改（例如 &AtomicU8</code>）。这要归功于内部可变性，正如第 1 章“内部可变性”中所讨论的那样。 </blockquote> 我们可以看到“原子操作是不可分割的”，放在我们的例子中这也就意味着我们可以通过原子操作，让线程的计算 x</code> 的值 和把算好的值存入物理内存 之间是不可分割的，那么也就不会出现前文中所述的错误，x</code> 就会是 200</code>。 Rust 是一门标榜“安全”的语言，既然多线程编程中会有“不安全”的场景出现，那么 Rust 肯定要考虑如何解决，不过相比 The book 中其他主题的 Rust 安全特色（所有权、借用检查等），我读到 Rust Atomics and Locks 后面只觉得在多线程编程方面，Rust 还是很明显地抄了不少别人（C++）的东西，例如下面 Mara Bos 博士话锋一转，开始讨论起了另一个概念： But, before we can dive into the different atomic operations, we briefly need to touch upon a concept called memory ordering: 但是，在我们深入研究不同的原子操作之前，我们需要简单地谈谈一个叫做内存排序的概念： Every atomic operation takes an argument of type std::sync::atomic::Ordering</code>, which determines what guarantees we get about the relative ordering of operations. The simplest variant with the fewest guarantees is Relaxed</code>. Relaxed</code> still guarantees consistency on a single atomic variable, but does not promise anything about the relative order of operations between different variables. 每个原子操作都有一个类型为 std::sync::atomic::Ordering</code> 的参数，它决定了我们对操作的相对顺序有什么「保证」。而「保证」最少的、最简单的变体是 Relaxed</code>。Relaxed</code> 仍然保证单个原子变量的一致性，但不保证不同变量之间的相对操作顺序。 What this means is that two threads might see operations on different variables happen in a different order. For example, if one thread writes to one variable first and then to a second variable very quickly afterwards, another thread might see that happen in the opposite order. 这意味着两个线程可能会看到对不同变量的操作以不同的顺序发生。例如，如果一个线程首先写入一个变量，然后很快写入第二个变量，则另一个线程可能会看到以相反顺序发生的情况。 </blockquote> 我之前说有更反直觉的东西，这不现在看到了？为什么第二个线程可能看到以相反顺序发生的情况？ Processors and compilers perform all sorts of tricks to make your programs run as fast as possible. A processor might determine that two particular consecutive instructions in your program will not affect each other, and execute them out of order, if that is faster, for example. While one instruction is briefly blocked on fetching some data from main memory, several of the following instructions might be executed and finished before the first instruction finishes, as long as that wouldn’t change the behavior of your program. Similarly, a compiler might decide to reorder or rewrite parts of your program if it has reason to believe it might result in faster execution. But, again, only if that wouldn’t change the behavior of your program. 处理器和编译器执行各种技巧以使您的程序运行得尽可能快。处理器可能会确定您程序中的两个特定的连续指令不会相互影响，并乱序执行它们（例如，如果这样更快的话）。虽然一条指令在从主存中获取一些数据时被短暂阻塞，但在第一条指令完成之前，可能会执行并完成以下几条指令，只要这不会改变程序的行为。同样，如果编译器有理由相信它可能会导致更快的执行，它可能会决定重新排序或重写程序的某些部分。但是，同样，前提是这不会改变您的程序的行为。 Let’s take a look at the following function as an example: 让我们以下面的函数为例： </blockquote> fn f(a: &mut i32, b: &mut i32) { *a += 1; *b += 1; *a += 1; }</code></pre> Here, the compiler will most certainly understand that the order of these operations does not matter, since nothing happens between these three addition operations that depends on the value of *a</code> or *b</code>. (Assuming overflow checking is disabled.) Because of that, it might reorder the second and third operations, and then merge the first two into a single addition: 在这里，编译器肯定会理解这些操作的顺序无关紧要，因为这三个取决于 *a</code> 或 *b</code> 的值的加法操作之间没有任何关联。（假设溢出检查被禁用）因此，它可能会重新排序第二个和第三个操作，然后将前两个合并为一个加法： </blockquote> fn f(a: &mut i32, b: &mut i32) { *a += 2; *b += 1; }</code></pre> Later, while executing this function of the optimized compiled program, a processor might for a variety of reasons end up executing the second addition before the first addition, possibly because *b</code> was available in a cache, while *a</code> had to be fetched from the main memory. 稍后，在执行优化编译程序的这个函数时，处理器可能由于各种原因在第一次加法之前结束执行第二次加法，这可能是因为 *b</code> 在缓存中可用，而 *a</code> 必须从主存提取。 Regardless of these optimizations, the result stays the same: *a</code> is incremented by two and *b</code> is incremented by one. The order in which they were incremented is entirely invisible to the rest of your program. 不管这些优化如何，结果都保持不变：*a</code> 增加 2，*b</code> 增加 1。它们递增的顺序对于程序的其余部分是完全不可见的。 The logic for verifying that a specific reordering or other optimization won’t affect the behavior of your program does not take other threads into account. In our example above, that’s perfectly fine, as the unique references (&mut i32) guarantee that nothing else can possibly access the values, making other threads irrelevant. The only situation where this is a problem is when mutating data that’s shared between threads. Or, in other words, when working with atomics. This is why we have to explicitly tell the compiler and processor what they can and can’t do with our atomic operations, since their usual logic ignores interactions between threads and might allow for optimizations that do change the result of your program. 验证特定重新排序或其他优化不会影响程序行为的逻辑不会考虑其他线程。在我们上面的示例中，这完全没问题，因为独占引用 (&mut i32</code>) 保证没有其他任何东西可以访问这些值，从而使其他线程无关紧要。唯一会出现问题的情况是在改变线程之间共享的数据时。或者，换句话说，在使用原子时。这就是为什么我们必须明确地告诉编译器和处理器它们可以用我们的原子操作做什么和不能做什么，因为它们通常的逻辑会忽略线程之间的交互，并且可能允许进行确实会改变程序结果的优化。 The interesting question is how we tell them. If we wanted to precisely spell out exactly what is and isn’t acceptable, concurrent programming might become exceedingly verbose and error prone, and maybe even architecture-specific: 有趣的问题是我们如何告诉他们。如果我们想准确地说明什么是可接受的，什么是不可接受的，并发编程可能会变得非常冗长和容易出错，甚至可能是特定于体系结构的： </blockquote> let x = a.fetch_add(1, Dear compiler and processor, Feel free to reorder this with operations on b, but if there's another thread concurrently executing f, please don't reorder this with operations on c! Also, processor, don't forget to flush your store buffer! If b is zero, though, it doesn't matter. In that case, feel free to do whatever is fastest. Thanks~ <3 );</code></pre> Instead, we can only pick from a small set of options, represented by the std::sync::atomic::Ordering</code> enum, which every atomic operation takes as an argument. The set of available options is very limited, but has been carefully picked to fit most use cases well. The orderings are very abstract and do not directly reflect the actual compiler and processor mechanisms involved, such as instruction reordering. This makes it possible for your concurrent code to be architecture-independent and future-proof. It allows for verification without knowing the details of every single current and future processor and compiler version. 相反，我们只能从一小组选项中选择，由 std::sync::atomic::Ordering</code> 枚举表示，每个原子操作都将其作为参数。可用选项集非常有限，但经过精心挑选以适合大多数用例。排序非常抽象，并不直接反映所涉及的实际编译器和处理器机制，例如指令重新排序。这使您的并发代码可以独立于体系结构且面向未来。它允许在不知道每个当前和未来处理器和编译器版本的详细信息的情况下进行验证。 The available orderings in Rust are: Rust 中可用的排序是： Relaxed ordering: Ordering::Relaxed</li> Release and acquire ordering: Ordering::{Release, Acquire, AcqRel}</li> Sequentially consistent ordering: Ordering::SeqCst</li> </ul> In C++, there is also something called consume ordering, which has been purposely omitted from Rust, but is nonetheless interesting to discuss as well. 在 C++ 中，还有一种叫做 consume ordering 的东西，它在 Rust 中被故意省略了，但讨论起来也很有趣。 </blockquote> 在这一大段里我们来捞点干的，大意是编译器会优化代码，导致指令执行顺序和代码表示的顺序不一定一致，而这一点在多线程环境下被放大了。不管是否有指令重排，第一个线程实际上并不关心，因为不会影响它的执行结果，而假如发生了指令重排，使第一个线程真实的执行顺序变得和原来相反，那么第二个线程就看到了相反顺序的发生情况，如果第二个线程的操作对第一个线程的操作顺序有所依赖，这就会出现问题。所以在某些特殊场合，我们需要有能力对代码/指令的执行顺序有所限制，如果你不想做上面 Mara 博士举例的“面向协议编程”，内存排序则是你的救星。 The different memory ordering options have a strict formal definition to make sure we know exactly what we’re allowed to assume, and for compiler writers to know exactly what guarantees they need to provide to us. To decouple this from the details of specific processor architectures, memory ordering is defined in terms of an abstract memory model. 不同的内存排序选项有一个严格的正式定义，以确保我们确切地知道我们被允许假设什么，并让编译器编写者确切地知道他们需要为我们提供什么保证。为了将其与特定处理器架构的细节分离，内存排序是根据抽象内存模型定义的。 </blockquote> Rust’s memory model, which is mostly copied from C++, doesn’t match any existing processor architecture, but instead is an abstract model with a strict set of rules that attempt to represent the greatest common denominator of all current and future architectures, while also giving the compiler enough freedom to make useful assumptions while analyzing and optimizing programs. Rust 的内存模型，主要是从 C++ 复制而来，不匹配任何现有的处理器架构，而是一个具有一组严格规则的抽象模型，试图代表所有当前和未来架构的最大公分母，同时也给出编译器有足够的自由在分析和优化程序时做出有用的假设。 </blockquote> We’ve already seen a part of the memory model in action in “Borrowing and Data Races” in Chapter 1</a>, where we talked about how data races result in undefined behavior. Rust’s memory model allows for concurrent atomic stores, but considers concurrent non-atomic stores to the same variable to be a data race, resulting in undefined behavior. 我们已经在第 1 章的“借用和数据竞争”中看到了内存模型的一部分，我们在其中讨论了数据竞争如何导致未定义的行为。Rust 的内存模型允许并发原子存储，但将对同一变量的并发非原子存储视为数据竞争──导致未定义的行为。 </blockquote> 计算机的难题 99% 是靠分层解决的，Rust 的内存模型也不例外，这里借鉴了 C++，或者说是编译器前后端/虚拟机的经验，不对某一具体处理器架构而是在这中间又加了一个抽象层，这样就能最大程度地保证灵活，除了多了一层翻译会有一点性能上的权衡以外没啥缺点。 激动，终于要谈到今天的主题──Happened-before 关系了，接着读： The memory model defines the order in which operations happen in terms of happens-before relationships. This means that as an abstract model, it doesn’t talk about machine instructions, caches, buffers, timing, instruction reordering, compiler optimizations, and so on, but instead only defines situations where one thing is guaranteed to happen before another thing, and leaves the order of everything else undefined. 内存模型定义了操作发生的顺序，即 happens-before 关系。这意味着，作为一个抽象的模型，它不谈论机器指令、缓存、缓冲区、时间、指令重排、编译器优化等等，只定义了一件事在另一件事之前发生的情况，而对其他事情的顺序没有定义。 </blockquote> The basic happens-before rule is that everything that happens within the same thread happens in order. If a thread is executing f(); g();</code>, then f()</code> happens-before g()</code>. 基本的 happens-before 规则是同一线程内发生的所有事情都按顺序发生。如果线程正在执行 f(); g();</code>，那么 f()</code> happens-before g()</code>。 </blockquote> 这里我补充一些内容： Mara 博士原文是 happens-before，这是编程语言的用法，但我更想讨论的是 happened-before 事件间的关系，故引述原文的地方我不做改动，但在我自己叙述的时候使用后者</li> 当 A 操作 happened-before B 操作的时候，操作 A 先于操作 B 执行，且 A 操作的结果对 B 来说可见。每个线程都可以执行不同的任务，但是当它们之间进行一些交互时，例如读写共享内存或发送和接收消息时，必须遵守一些规则。这些规则确保了在一个线程中发生的操作在另一个线程中变得可见之前已经完成。也就是说，在一个线程中发生的操作 happened-before 了在另一个线程中看到该操作</li> happened-before 包含两种情况：</li> </ol> 对于同一线程内的 happened-before，其等同于 sequenced-before（A sequenced-before B → 代表 A 的求值会先完成，之后才进行对 B 的求值）</li> 对于不同线程内的 happened-before，其等同于 inter-thread happened before（A inter-thread happened before B → 如果操作 A happened-before 操作 B，则可以保证线程 1 中的操作 A 的执行对线程 2 中的操作 B 的执行是可见的，也就是说，操作 A 执行后对共享状态所做的修改对线程 2 可见）</li> </ul> Between threads, however, happens-before relationships only occur in a few specific cases, such as when spawning and joining a thread, unlocking and locking a mutex, and through atomic operations that use non-relaxed memory ordering. Relaxed</code> memory ordering is the most basic (and most performant) memory ordering that, by itself, never results in any cross-thread happens-before relationships. 然而，在线程之间，happens-before 关系只发生在少数特定情况下，例如 spawn 线程和 join 线程、解锁和锁定互斥锁以及使用非 Relaxed</code> 内存排序的原子操作。Relaxed</code> 内存排序是最基本（也是最高效）的内存排序，它本身不会导致任何跨线程的 happens-before 关系。 To explore what that means, let’s take a look at the following example where we assume a</code> and b</code> are concurrently executed by different threads: 为了探究这意味着什么，让我们看一下下面的示例，其中我们假设 a</code> 和 b</code> 由不同的线程同时执行： </blockquote> static X: AtomicI32 = AtomicI32::new(0); static Y: AtomicI32 = AtomicI32::new(0); fn a() { X.store(10, Relaxed); // 1 Y.store(20, Relaxed); // 2 } fn b() { let y = Y.load(Relaxed); // 3 let x = X.load(Relaxed); // 4 println!("{x} {y}"); }</code></pre> As mentioned above, the basic happens-before rule is that everything that happens within the same thread happens in order. In this case: 1 happens-before 2, and 3 happens-before 4, as shown in Figure 3-1</a>. Since we use relaxed memory ordering, there are no other happens-before relationships in our example. 如上所述，基本的 happens-before 规则是同一线程内发生的所有事情都按顺序发生。在这种情况下：1 happens-before 2，3 happens-before 4，如图 3-1 所示。由于我们使用 Relaxed</code> 内存排序，因此在我们的示例中没有其他 happens-before 关系。 </blockquote> Figure 3-1. The happens-before relationships between atomic operations in the example code. 图 3-1 示例代码中原子操作之间的 happens-before 关系。 If either of a</code> or b</code> completes before the other starts, the output will be 0 0</code> or 10 20</code>. If a</code> and b</code> run concurrently, it’s easy to see how the output can be 10 0</code>. One way this can happen is if the operations run in this order: 3 1 2 4. 如果 a</code> 或 b</code> 中的任何一个在另一个开始之前完成，则输出将为 0 0</code> 或 10 20</code>。如果 a</code> 和 b</code> 同时运行，很容易看出输出是 10 0</code>。发生这种情况的一种方式是操作按以下顺序运行：3 1 2 4。 </blockquote> More interestingly, the output can also be 0 20</code>, even though there is no possible globally consistent order of the four operations that would result in this outcome. When 3 is executed, there is no happens-before relationship with 2, which means it could load either 0 or 20. When 4 is executed, there is no happens-before relationship with 1, which means it could load either 0 or 10. Given this, the output 0 20</code> is a valid outcome. 更有趣的是，输出也可以是 0 20</code>，即使没有可能导致此结果的四个操作的全局一致顺序。当 3 执行时，与 2 没有 happens-before 关系，也就是说它可以加载 0 或 20。当 4 执行时，与 1 没有 happens-before 关系，这意味着它可以加载 0 或 10。鉴于此，输出 0 20</code> 是一个有效的结果。 </blockquote> The important and counter-intuitive thing to understand is that operation 3 loading the value 20 does not result in a happens-before relationship with 2, even though that value is the one stored by 2. Our intuitive understanding of the concept of “before” breaks down when things don’t necessarily happen in a globally consistent order, such as when instruction reordering is involved. 需要理解的重要且违反直觉的事情是，操作 3 加载值 20 不会导致与操作 2 为 happens-before 关系，即使该值是由操作 2 存储的。当事情不一定以全局一致顺序发生时，我们对“before”概念的直觉理解就会崩溃，例如当涉及指令重排时。 A more practical and intuitive, but less formal, understanding is that from the perspective of the thread executing b</code>, operations 1 and 2 might appear to happen in the opposite order. 一种更实用、更直观但不太正式的理解是，从执行 b</code> 的线程的角度来看，操作 1 和 2 的发生顺序可能相反。 </blockquote> 迷糊了吧，我也迷糊了，我始终无法理解 0 20</code> 是怎么成为一个有效结果的。首先输出 0</code>，这意味着操作 4 在操作 1 之前发生；输出 20</code> 则意味着操作 2 在操作 3 之前发生，而最关键的“基本的 happened-before 规则是同一线程内发生的所有事情都按顺序发生”，那么也就是说操作 3 在操作 4 之前发生，操作 1 在操作 2 之前发生，我是没有想得到是什么样的全局顺序能够满足这些要求，无论怎么想都有矛盾，Mara 博士也说这个例子中并没有能导致该结果的四个操作的全局一致顺序，所以如果还在这个方向思考，肯定是难以得到简单直观解释的。 让我卖个关子（其实已有伏笔），欲知后事如何，且听下回分解。

杭州游记

2021-07-03T00:00:00+00:00

我毕业了，为了出来散心，选择到杭州旅游。

为什么来杭州呢？也没有什么特别的理由，首先我想来一座南方的城市，感受一下和北方的不同；其次去哪里无所谓，重要的是独自旅行的过程，虽然也是一种无奈；另外杭州的名气比较响亮：“上有天堂，下有苏杭”，浙江也是社会主义共同富裕的先行示范区，我想看看是怎么个先行示范的样子。

一直到旅程结束我在家里写这一篇博客的时候，都很难讲杭州是一座怎样的城市，限于各种原因我只能走马观花：杭州看起来年轻十足，年轻小伙子姑娘很多；杭州又十分忙碌，晚上10点的地铁依然是人挤人；杭州也有闲散舒适，这里的老头一样喜欢饭后打牌；杭州同时繁华，这里城市建设一流，消费主义盛行，花花世界迷人眼，各种商场随处可见，仿佛就是要人们“消费、消费、消费”，可能是浙江人有钱不在乎这些，也可能是我在景区待久了的原因。但景区也有景区的好处，比如杭州的垃圾箱和公共厕所很多，这一点确实很方便旅客。总之，经过几天的旅行我还是难以看懂这里，但已经知道这里和我从前待过的任何一处都很不一样。

杭州大妈也很热情，得知我是从辽宁来的时候纷纷表示：“哦呦，好远”，“你北方人不习惯吧”，“杭州菜偏甜”等等，另一种热情是景区的大妈，她们热心的方式是请你“喝茶”，来之前我查了一下杨梅岭骗局，对此早有戒心。

这次旅行中也遇到了很多有意思的人：青旅的舍友王祚彦先生，一位执意寻找”西湖老公“的江苏台湾冒险家，他的旅行经历相当丰富，也给我很多见闻和思考；永福寺的哈尔滨老奶奶，年轻时在北京教书，退休之后在各地旅游，是一位非常坚定的”考研党“；还有很多热情的杭州人，他们是这个闷热城市里的习习凉风，吹散我很多疲惫，在此诚心谢谢他们，使我的旅行不仅仅是旅行。

用双脚丈量土地这个说法听起来很浪漫，实际上的感受更多是一个字：累。在路上和日常的生活感受完全不一样，我也开始理解为什么有很多人迷恋这种在路上的感觉，不仅仅是娱乐和享受，而是追求一种未知的改变，这种感觉可以赋予人一种生活的激情，焕发出新的活力。

短短四五天，毕业旅行走到尾声，我挥一挥衣袖，带走了很多照片，也算不虚此行，说罢杭州好，我还是思念辽东的凉爽。

把自己作为方法

2021-06-05T00:00:00+00:00

其实是读书笔记。

北大青年的焦虑</h2>

我妈妈回了一封信，我的印象比较深，她说她年轻的时候什么都学苏联，现在什么都学西方，这是一个问题。 </blockquote>
所以中国的情况变化了吗？这是一个问题。我们究竟是谁？要干什么？

我感觉他们对这个社会在今天发生什么也没有兴趣。 </blockquote>
可能确实如此，互联网的信息密集令人迷失，即使什么都不做也会有“算法”给你找乐子，虽然那不一定算是乐子。

他们对这些事情不感兴趣。不感兴趣，又写这方面的文章，就很空洞，里面没有什么实在的观察。 </blockquote>
有些“学人”只是为了表面的享受，学术并没有走进他们的生活。

大二以后，我比较重视数学和英语，觉得这是比较实在的东西，也去学经济学的课，剩下的时间就是做“浙江村”调查，以及搞社团 </blockquote>
项飙在他大二的时候觉得数学和英语是比较实在的，联系到他求学的年代是90年代初期，这么一算，30年过去了，我倒没在大二产生这样的想法，而是大一就认识到了。
但这也没能如何，毕竟人家上的是北大。不过跨越这么多年，大学生所产生的想法依然有一定程度的重叠，这是很奇妙的。
项飙还提到做调查和搞社团，放到今天来看这就是做比赛和玩社团的翻版，项飙做的调查使他的起步很高，但也许并不是出于功利想法，今天可就不一样了。
今天的比赛之类没有那么学术，甚至也不是为了娱乐，而是规则扭曲下的产物，核心在于利益竞争；至于社团，年轻人甚至不屑于跟现实世界里身边的人沟通，当然他们到了互联网上，到了游戏里又是一副样子了，可想而知社团的情况，一潭死水而已。

青年很重要，不在于我们去回想自己的青年时光，而是用今天青年的眼光去拷问我们，让他们来“审判”我们，这样才能有更真的东西，我们才有机会来反思自己。 </blockquote>
每一代青年都是特定时代的产物，其中也会有怪胎。
不过每代人都觉得自己的时代是最乏味的，其实没有什么可拷问。年轻人不关心这些。

这种学生下海赚钱的事其实在1991年就有了，但在1992年一下子爆发出来，市场经济被认为是正统。各种文化现象也重新出来，比如新一轮“国学热”。 </blockquote>
这一段令我印象深刻的是项飙居然可以如此清晰地记住像“1991年”这样的时间节点，今天的中国我很难对某件事有清晰而具体的隔断，一般是以段时间来划分。
另一方面赚钱的事其实早就有了，罗马不是一天建成的，社会风气也不是一天就变坏的。

资源是什么意思呢？就是在私有化市场经济之后，原来我们生存所需要的物质，现在转化成了潜在的资源，是可以升值的。你一定要占据，要有明确的产权。 </blockquote>
这一段相当精辟。非常准确传神地带有一种社会风向转变的角度的叙事，有一种醒悟感：原来不能卖的现在可以卖了，世界的规则变了。大多数人们并不知道的是，某种残酷就要到来。

同时我们对腐败官员的揭露，却把大量篇幅放在男女关系上，而对这个人究竟怎么贪污、制度设计哪里有问题、贪污造成的具体后果又讲的很虚幻？ </blockquote>
很本质也很准确，不过这是讲不了的问题，项飙这样说很明显透出一种学者的稚气，其实虚幻已经给你答案了不是吗。
研究“浙江村”</h2>
很有意思的一点是之前认为“浙江村”在温州，原来是在北京。这样项飙上大学的时候去做研究就说的通了，毕竟那个年代不太可能长期两地来回跑。
由此看来，一个人的故乡很重要，例如项飙早期最重要的调查其实都没逃出他的“温州”，不过这也很合理，谁也不是石头缝里蹦出来的。

冲动是每个人都有的，关键不在于你有没有冲动，而在于你是不是让冲动推着你走。 </blockquote>
我几乎从未让冲动推着走过，也许这就是我目前还是一事无成的原因。
项飙的“浙江村”调查，在他的叙述来看，完全是一副高材生的典型成功案例，站在高台上做一些不那么容易的事，只要做出水准之上的东西就足以收获很多。

因为我们大量的信息和思考方式是一定要通过文字表达出来的，积累确实很重要。 </blockquote>
文字 → 表达，这是很多人都提到过的概念，我也认为文字传递信息，高效而方便。虽然不像游戏、视频那样给人很高的刺激，但是性价比很好。

这是我长期以来的一个弱点，还在挣扎当中。我必须要追赶，但也不能够放弃自己的特点，把自己搞成那样的人。怎么弄现在没有结论，还在继续追赶，我们二十年以后可以再讨论这个问题。 </blockquote>
人人皆有弱点，即使像项飙这样的大学者也不例外。
我认为得到一些就会失去一些，如果我的偏好对我而言我足够喜欢，那么我会接受拥有他而失去的代价。
直接有直接的好，含蓄有含蓄的美。

理论不在于新不新、深不深、更不在于正确不正确，而是能不能形成沟通性。 </blockquote>
这恰恰是最难的一点，和谁去沟通？

艺术上的热情还是比较自然的，爱画画的人总是爱画画，但其他工作，比如研究性的、公益性的，会牵扯到很多很繁琐的细节，确实要有一种持续的热情。不能完全靠自发，而是需要通过教育。艺术真正的魅力是产生一种视觉效果，让对方去思考、反思，有思考的引带力。 </blockquote>
为了生活而又高于生活。

如果赚钱糊口不是主要的目的了，你的生活意义是什么，你怎么和社会形成关系？ </blockquote>
到这一步我至少5-10年，所以不用急着回答。
边缘与中心</h2>

真正的英雄不是改变世界，而是改变自己生活的每一天。 </blockquote>
醍醐灌顶。

边缘的人要进入中心的欲望特别强，这当然会让人发挥很大的能动性，但造成各种扭曲。而且一旦进入中心之后，很多人变质腐败，因为他们从来没有把自己是谁想清楚，存在就是为了进入中心，把生他养他的土地、和周边人的关系都放弃了，变成没有原则的人。人生活中的原则不是靠抽象理念来维持的，都是靠具体的社会关系，这个当然是儒家的思想，但它确实有它的道理。如果跟周边的人、生活的世界关系不清楚，就会变成机会主义者，其他人都成了利用工具。 </blockquote>
基本把人的割裂讲明白了，所以把自己想明白就是在救别人。

中国历史上的强大中心，很大度上是靠把这个中心内化，每个地方都觉得自己是个小中心，所以都会比较从容。然后把它在象征意义上给拢起来，所以既有大一统，但是又不会削尖脑袋往上爬，觉得自己的生活一无是处。其实中心对很多边缘地方是不管的，地方有很强的自主性，是那种柔性的、开放的关系。今天“地方”的文化意义真的是被抽空了，搞一些地方博物馆、旅游，都不能够进入人心，所以处理好“边缘”和“中心”的关系是很重要的。 </blockquote>
角度很奇妙，同时很合理地解答了我心中长久以来的困惑，讲明白了地方和中央的关系：你当大哥，我做小弟，但咱也是个土皇帝，犹如各玩各的、貌合神离的所谓“夫妻”那般暧昧。

大一统并不意味着一个刚性结构，但现在环境已经变了，今天我们是一个很强大的国家，确实需要强大的中心，因为有资源再分配的问题，比如上海和西藏的关系，要有互相帮助的精神。所以我强调文化和社会的自主性，但是在经济上，市场要统一，资源上，通过行政力量来二次分配，还有军队税收，这些都不能放松。第二个变化就是全球化。自洽不能是封闭起来的自洽，而是每个地方都是一个小的中心，是汇集的地方，一个穴位，贯通全身，要用这样的方式去思考。 </blockquote>
这个回答很有中国味道。

那时中国对世界的影响，我觉得比今天要大。今天我们究竟摸索出了一条清晰的道路，或者是提供了一个很大的理想吗？今天的情况又不一样，今天的中国走向世界，主要不是靠输出理念，而是靠做贸易。 </blockquote>
输出革命和做生意可不一样。

但更可能的是，要等一批人积累起来以后，才会对这个世界有普遍性的启发。中国是在这样一个全球化的环境下崛起，靠中国的独特性去讲世界的普遍性问题，这个蛮牵强，还不如把自己具体的问题讲清楚。把这一角讲清楚，其实就是全世界的话语。 </blockquote>
个人危机</h2>

如果我不在当地泡，就是在说空话，唯一的干货来自人民群众。观点属于人民，把观点整理出来，这个就是我们的工作。 </blockquote>
这两句话的左派气质已经藏不住了。

不要怕边缘，或者知识不够，把自己的不够、天真真实地体现出来，就会很可爱，不要装腔作势。只有知道了你的真实性之后，才可以信任你。当然东方文化在政治上是相反的，这些东西都要被屏蔽，领导人不是个人，他是权力的化身，这就是不太一样的理解。到了牛津，我很感谢他们给我这么一个工作，使得我能想这些问题。 </blockquote>
真实是强大的力量，当然恐惧也是。

“距离感”是分析上、方法上的概念，它和切入性是一种辩证关系。距离感不是指对问题的关心程度、对事实的熟悉程度，这些不能有距离感，越近越好，要把自己融进去。但在分析的时候，要有登上山丘看到平原的心态，才会比较客观、灵活、全面。 </blockquote>
分寸感能令双方感觉从容不迫。
什么是批判</h2>

学术也是这样，不能靠直觉去判断，一定要去证明它，要去展示结论是怎么达到的。往往越是明显的结论，越难去证明，但是一旦证明了以后，会是很大的贡献。 </blockquote>
返璞归真，最难是真。
理解的学问</h2>

有人甚至断言理解是不可能的。您怎么看？ </blockquote>

理解是很自然的，不难，重要的是怎样不去拒绝理解。</li>
要真的懂你，聊一聊是不够的，因为我不知道你从哪里来的这些感觉，所以一定要知道你的世界。从了解开始，才能真正地理解。</li> </ul>
重要的是怎样不去拒绝理解这句话说出了关键，也许自己应该放下那不该有的傲慢，真诚地对待人类。

要把他的言和行都看作是他的行动。只有通过这样理解，我们才知道我们应该怎么面对这些社会病态：不能把人一棍子打死，要考虑如何沟通，否则对罪犯就只有放纵和消灭两种态度了，没有教育改造一说了。 </blockquote>
世界当然不是非黑即白的，可是
访谈之前</h2>

社会科学告诉你，其实没有什么很强的规律，都在于自己怎么样去理解这个世界，怎么样主动地采取行动。可能会有大的图景，但没有所谓的规律，因为一旦发现规律，那么一切到此为止，就不需要再去做工作了。 </blockquote>
这是一种反直觉式的思考，甚至可以说不太理性，很唯心，和工科思维很不一样。

社会科学首先是关于你的，然后才是关于社会的。 </blockquote>
其实任何一门科学都差不多吧，先从自身角度出发，然后扩展到很宏大的层面。

在中国，很多事情能不能撑下来，关键在于有没有这口气，如果你有这种小型的团结，有时候像牛皮糖一样，这个事情也就拖过去了，能做下去。不要期望有一个人帮你挡，有困难大家一起面对。 </blockquote>
这个就和PHT想要抱团的想法不谋而合，这么看来即便在异国，他的思维也没有脱离中国太多。
而我有更加现在中国的看法，像张一鸣最近把字节交给和自己一起创业的南开的梁汝波，这就是普罗大众能接触到的这种小型团结的体现之一。
因此给我的启示之一是：对每个人来说，小团体是必然要出现的，你可以游离在大团体中，但必然要有自己的小团体，要有一处互相支撑的地方。
牛津记忆</h2>

这种一对一的辅导最大的好处是什么？他们说最大的好处就是躲不过，懂就是懂，不懂就是不懂 </blockquote>
条件所限，我只能自己给自己一对一辅导了。

社会生活里有很多问题都是老问题 </blockquote>
因此很大一部分的经验还没有失效，关键在于你要分清楚哪些问题是老问题。

表面上是政府在办牛津，事实上是牛津在办政府。 </blockquote>
这话说的，牛气！不过清北也差不多了？当然，不要忽视东方霍格沃兹。

其实大学的作用就是提供了一个安全的环境，让你做思想上的各种探索。 </blockquote>
说的有一半贴切，一半理想化。比如我到想起来要关注思想的时候人多半已经不在大学里了。

高水平的大锅饭比较好，没有竞争压力了，大家最独特的才华才会体现出来。 </blockquote>
可是只有当社会的水平达到一定程度才能这么玩儿，中国的体量，绝不可能做到如此宽松的地步，无论哪个阶层永远都有相当数量的人想改命，也就不能吃上大锅饭。小国寡民不适合中国。

你自己有多聪明、能写多少书，这个很重要吗？关键是你能培养出什么人。那些真正厉害的人，带学生，一辈子写两三篇文章，就能改变人类历史。考申请课题搞出来的东西，到底有多大的价值，确实存疑 </blockquote>
那问题是：不是人人都能有这样的水平，但是却提供了大量的岗位，总不能为了宁缺毋滥不招人了吧，饭还是要吃的。
那么我们要做到：如果天才来了，别去挡他的路。
距离感与直接性</h2>

主体性不是说“我很厉害”、“我很特殊”，完全不是这个意思：而是说我作为一个人在这个世界上，我和世界是什么关系，我看到了什么，哪怕我的看法不对，但是应该把自己怎么想的搞清楚。 </blockquote>
先从问题出发，把自己想明白，项飙很强调想清楚自己，在认识世界之前，先要有自我。

这跟你的物质利益到底有什么关系？要把这个问题讲清楚，你的行为才有意义。 </blockquote>
同时也讲实际，先不管情感上如何，能不能在硬件上先达到？这是一个可以去反推的手段。

一定要有从内到外的冲击力，有情绪的积累。 </blockquote>
这是后期要做的事情，之前主动摒弃情感，现在把它再拿回来，做一个总结与积累，是一个过程的收尾。
非虚构写作</h2>

你要把自己是什么想清楚。“认命”是说从历史、结构的角度，想清楚自己是什么。 </blockquote>
这个对“认命”的解释令人耳目一新，回到之前论述的主题 → 想清楚自己是什么。
学术不是天职</h2>

“跨语言的自我”，翻译成为一种思想方法，朋友之间的交流也可以是一个方法，很重要的功能是逼着你去想这个about。 </blockquote>
两种文化的交锋，语言代表了背后的文化，是一种投影。使用双语就是在让自己在两种思考方式之间进行转化，可能产生很独特的、很好的、经过两种文化检验过的、真正了不起的东西。
但也可能四不像。
民族与民粹</h2>

清楚现实状况的人，文章是不可能写得那么正式的，因为事情非常复杂，搞出一二三四五六，只是贴标签，其实是不完全清楚。 </blockquote>
这个是我从未想到的，但可以解释一些现象。

作为过渡，我就去了新加坡国立大学，在亚洲研究所做博后。新加坡国立大学对我生活的影响非常大，我在那里碰见了我的爱人，她也在亚洲研究所。 </blockquote>
所以说，你不知惊喜在哪里冒出来，不要放弃学习！

新加坡最让我觉得可圈可点的地方，还不是像杜赞奇和安东尼-瑞德这样的一批人，而是他们背后一群兢兢业业的人。你可能从来没听过他们，他们往往都是女性，也许没有很大的想法，看起来没有什么天才的创造力，就是埋头苦干，有非常专业的精神，建立团队，有宽容的态度，做事情比较无私。 </blockquote>
新加坡的这样的一群人决定了所在群体的下限，他们也许上限没有多高，但是下限绝对不低。这是很重要的隐形实力。
联想到之前和某人关于对亚洲某发达国家的讨论，也许在那里有很多这样的人，无关男女。

夸夸其谈相当可怕，好像一种灵感让自己感动起来，但是飘过去了就什么都没有。 </blockquote>
传神，无奈。
新加坡启蒙</h2>

她让我理解到电影、诗歌、艺术、民谣其实和学术一样，都是人类自我表达的方式。 </blockquote>
很多事情首先都是从认识自我开始，然后慢慢就有了表达欲。

因为从小到大，学习是天职，从来不问为什么学习，没有想过学术和寓言其实是一回事，跟唱歌是一回事。 </blockquote>
我的启蒙从大学开始。我为什么学习，学习是什么这两个问题我已经有答案了。
首先回答第二个问题，学习是生活的必须，如果想要把自己的想法落实，学习是必要手段；其次，生活里基本所有的元素都可以通过学习重构，触发改变，这其中当然就包含了进步，这样也就回答了第一个问题，我想做到想做的事，因此要学习。
我现在认为学习是改变的一部分，同时也是改变的开端。
跨国性的自洽的小世界</h2>

这个小群体越是具备异质性、多样性，它的抵制的能力就越强，就会更加有机。 </blockquote>
这个对会议很有参考意义，我们应该一上来就去选择非常不一样的人，尽管会带来很多挑战。对于学习或者工作，这样的关系应该尚能维持。

对于学者来讲，小世界首先是一个被构造的过程，其次是不断骚动的过程。你构造它，它逼着你，刺激你去反思自己，批评自己，不断冲破原来的理解。它越是活跃，越是骚动，给你的安全感越强，因为你的生存就是你的思考，如果不断觉得自己在思考，就很明确地感觉到自己在生存，不用为生存害怕，因为思想活着。 </blockquote>
构造是在满足表达欲，这个构造的过程会产生很多奇妙的反应，会改变你，持续不断。
项飙说生存就是思考，那么只要还在思考，我们就永生。

真正的全球性只存在于无数的地方性之中。贝多芬是全世界的，但他首先是欧洲的，不是非洲的，不是拉美的。为什么欧洲的音乐家比非洲的音乐家更“全球”？这是个问题。 </blockquote>
前半句是在说万事皆有顺序，先小而大；后半句的观点其实很容易解释，欧洲有钱有技术，因此有人，非洲只有才华，冒不出头。
大学应该寻找例外</h2>

每个时代大学的功能都不一样。我们进入了一个物质相对充裕、城市教育水平相对高的时期，所以“人的生产”变得越来越重要。 </blockquote>
所以这是不是在说：从前的人没那么重要？
尽管真相不中听，现在的人，也没那么重要。大学确实应该认识到时代的召唤，进而改革，可是改革就要流血，不是每个人都愿意流血，你还不知道你的改革会让谁去流血。
因此先驱令人敬仰，不光是因为他们敢自己流血，而且也是因为他们做好了让大家都去流血的心理准备。

大学不是去树立范例，而是要去寻找例外。 </blockquote>
这么看，现在的大学热衷于造神，离项飙的想法还远着，几近背道而驰。
大学不去寻找例外，我们自己去找，自己的、别人的、亲人朋友的、陌生人的，通通来者不拒。

但是恢复高考把此前的官僚和城市知识分子一下子拢进来，其实是一个政党和当时社会主义体制下的精英的重新联盟。大学当然是搞精英主义，你看现在回忆恢复高考的人，很多都是干部子弟，从农村回到城市，不仅恢复了原来比较优越的地位，而且用这种途径在文化、道德上使自己的优越正当化、合法化。现在我们的大学是主流中的主流，大学也以此为豪。 </blockquote>
个人问题经验化</h2>

“打通”是什么意思，这个词我们已经说过很多遍了，打通就是回到实践，因为实践是最盘根、最通的！怎么样回到实践？从哪里回到实践？就是要从这些书本上学到的概念、范畴、理论、教条、框架离开，新的基础就是实践。但实践是那么流动、那么无情，怎么把握？个人经历就是开始把握的起点。 </blockquote>
在实践中总结自己的经验，反推回之前学的东西 → 解构、重构。
新研究</h2>

要真正通向上帝，必须通过自己的语境和语言，那是通向上帝唯一的思想途径。 </blockquote>
母语是根源，包容一切。人无法脱离根源，连上帝也不能免俗。

现在我们共同的超越性的理想没有了，下面又没有空间，大家每天糊里糊涂。 </blockquote>
解放全人类的激情褪去之后，犹如理想破灭，那可不就是行尸走肉吗？原来是难得糊涂安慰自己，现在是醉生梦死麻痹自己。

整个法律就写成让你时刻准备着离婚，有点这个意思。比方说两人结婚二十年，女方工资水平比较低，但对家庭付出大量的时间、精力的投入，到离婚时这些都不算，只算你名下登记的资产。《司法解释三》通过的背后的一个原因是说很多女性傍大款结婚，结婚后很快离婚，要拿一半财产，所以法律要保护大款。很明显，对比来看，就能看到法律对谁的声音更敏感。 </blockquote>
因此对于一些国家出台的政策，你要认真想一想到底和你有没有关系，不过大家也不是傻子，有很多人都很清醒。
某些话有人能听懂其中隐含的意思，可能是因为那些话是专门说给那些人听的。与你无关，你自然很难听懂，不要自作多情。

但后来到现在，基本上就是城市里面受过高等教育的人在讨论，哪怕在社交媒体上，也很少听到工人的声音。 </blockquote>
这带来两个问题：

社交媒体是否本身就具有门槛，将一些人置之门外？ </li>

工人也是人，也会有表达欲的需要，既然他们不在社交媒体上满足表达欲，那么是在哪里？ </li> </ol>
回答：

也许是，因为时代的受教育文化因素等影响，不过在可见的未来十几年，会有大量工人涌进互联网。 </li>

以我父辈为例，表达欲是在和朋友的现实交流中完成的，例如酒局，其实承担很大一部分的社交功能，即便看起来很没意思，但那是大家共同选择的游戏方式，想玩就得入局。 </li> </ol>
共同理想</h2>

不是从理念上改变自己、重新树立理想，而是知道自己已经背叛了理想，现在要通过一切手段来自保，不允许任何人说话，所以现在的情况是比较复杂的。 </blockquote>
其实很可悲，但问题是，你的可悲不要来烦扰到我。可惜这种可悲更多意义上是一种奢侈品，绝非人人皆有，拥有它的人可以轻易影响别人的生活，这也是复杂的来源。

现在世界的问题这么多，中国当然要努力走出不一样的路，但现在主流的心态，不是说要走不一样的路，而是取而代之，要当老大，很多基本的想法和美国非常类似，我觉得这和共同理想的丧失都有关系。中国在什么时候最令世界钦佩？那就是上世纪五六十年代。从万隆会议开始，到第三世界理论的提出，中国在国际上的影响非常大，引起了很多国际上的争论。 </blockquote>
这当然是理想破灭的后果之一，既然选择了不一样的路那就是必然，要了解过去，但不能沉湎。如果真的想重现当年的辉煌，那就重新走当年的老路，反之，洗洗睡吧。

要证明自己其实就是没有自己，意思是说，要通过已经预设的原则和标准、别人的逻辑和流程来证明自己的存在，其实是取悦别人，把自己搞没有了。自我证明是很危险的。 </blockquote>
但在今天，想要活着，挣钱，就要时时刻刻证明自己，哪怕要牺牲自己。每个人都在这个罗网里没有解脱。也许在生产资料高度发达的、具有高度人类责任感的社会才能真正有尊严地活着吧。
乡绅作为方法</h2>

如果人民代表制度不能被有效激活，那么现在的政治环境里面，似乎没有什么真正的沟通渠道。– 吴琦 </blockquote>
谁说一流的知识分子对时局不清楚？他们明明清楚得很，还是不能小瞧任何人，收起对他们不切实际的想象，把自己作为方法，重新看待世界。
访谈之前</h2>

现在年轻人说，不用下结论，也不用从高大上的原则出发，就是讲自己的经验，经验比较琐碎，乱七八糟没有关系，只要是真的就有意义。这是一份从容和自信，这是相对新的，跟年轻人的教育水平、城市化的生活方式都有关系。 </blockquote>
吃饱了之后会去想一想的人正在越来越多地浮现出来，毕竟思考也是一种活动。
思考之后，会有一些不一样的东西进来，包括自尊。
人的再生产</h2>

“人的再生产”跟“人的生产”不一样，“人的生产”是说人怎么样被培养成一个生产的要素，而“人的再生产”就是人怎么样再生产自己，自己成为目标。 </blockquote>
让人成为真正的人，去做只有人才能胜任的事，让人类给人类自己存在的意义。

再去看资本主义本身的变化，现在谁是赚钱的大户，平台可能是第一，第二就是跟“人的再生产”有关系的教育、医疗、娱乐等各种服务，接下来可能是采掘和农业，所谓第一产业。 </blockquote>
在人的再生产之前还有项目，说明我们还没有完全解放自己，不过我看情况已经很有转机，也许下一个阶段真的不远了。

这也促使我思考如今“人的再生产”的问题，这其实是一个很重要的政治问题，看起来最不政治，但政治就在这里出现。 </blockquote>
在一定高度上看，政治无处不在。
今天的政治是否有了新的含义？不得而知。但可以肯定的是会有一些变化，围绕人的斗争形式上丰富起来几乎是一个必然结果，这也就导致了一些看起来不政治的问题实际上就是政治问题。

政府鼓励的不是真正回国定居工作，而一般是短期回国甚至不回国服务，从回国服务变成为国服务，这是一个很大的转变。 </blockquote>
这里可以看出政府的格局，见过世面之后，“物以稀为贵”的“稀”会经过提纯，变得纯粹了起来；某些事上不再讲面子，而是要里子，底气足了之后做一些符合自己状态的事，这是政府的进步。
阶层流动的悖论</h2>

一个是到目前为止基本上大部分人还是往上流动，因为经济总量还是在扩张。第二个特征，中国的社会分化是一种全民参与式、以市场为基准的社会竞争。第三个特征，纵向分化又跟横向的流动紧密联系在一起。社交媒体分层又造成更大的分割、破碎化，很难形成动员，在思想表达上很同质。但像中国的这么大规模，人人都不认命，这可能不是经常出现的现象。 </blockquote>
原来有人往上流动是因为经济总量还在扩张才能办到，不是有人穷有人富的动态过程，而是有人如果富，很大可能会一直富下去。那么如果经济总量不再扩张，悲观看就不会再有新人富起来了。
仔细一想好像真的是这个道理，发达国家的阶级流动远远小于中国，只是他们的平民阶层相对优渥的生活掩盖了这些现象。天下的乌鸦很快就要一般黑了。

现在我们好像被绑架了，一定要更高更快更强，正是因为不太愿意进行激烈的再分配，已经获得的人还要获得更多，同时又要把下面的人也提上去，这个确实很难，今后可能还是要慢慢走向再分配的思路。 </blockquote>
项飙认为今后可能要慢慢走向相对温和的再分配，我认为这将会是一个长期博弈过程，里面充满了变数，如果真有人人发财的路子，美国早就去做了。
再分配是历史发展的主旋律，小到劫富济贫，大到社会变化，都是这种主旋律的集中体现。联系到现在既去政治化又加强政治化的特点，我认为事情可能会走向最危险的境地，会发生相当剧烈的变革，然而变革之后又会是什么样子？天知道。
寻找新的话语</h2>

放在上世纪90年代或者2000年初，那时还有关于左与右的讨论，两边对于中国社会的描述以及背后的原因，都有具体的指向，比如左翼认为是资本主义这个大的系统出现问题，右翼说是权力本身的腐朽和话语的滞后。但现在一个很大的问题是，首先这个对立慢慢在消失，其次可能也因为对立的消失，公共话语本身也消失了，没有回应大家实际的感受，所以有一种普遍的不知所措。一方面感受到自己的生活出现了具体的变化，也包括进步，但另一方面又觉得不足够，不知道怎么理解，也不知道对抗什么，索性不想那么多，生活还能照样过，也蛮舒服。 – 吴琦 </blockquote>
这也是我看到的困惑，当吃饱了饭，矛盾没那么尖化的时候，似乎每个人都无所适从了，集体迷失方向感，再没有一个强人出来给大家指明方向，抑或者是人人都想得很明白，但又没有推广性，难以有沟通全员的共识存在。

在今天，生活方式跟资本、国家权力同等重要。 </blockquote>
还是上述观点的延伸，饱暖思淫欲。

文化这个概念可能会引起误解，一讲文化大家就觉得是文学、艺术，其实它就是指生活方式、日常经历、生活意义，包括抖音这些，六七十年代的文化研究，和在此之前的法兰克福学派给了我们很好的例子。 </blockquote>
原来我们觉得“粗俗”的东西实际上就是生活的一部分，然而经过一定程度的教育我们好像把“生活”本身视作一种“罪恶”，其实是不够了解自己。

比方说我会倾向于去讲去政治化或者非政治化，比如物流型权力、基础设施权力，这些都是讲公共事务变得越来越被技术化地处理，人民内部矛盾用人民币解决，不管有理没理，就是给钱，对错不重要了，这就是我说的去政治化的意思。香港也是一样，商人治港，别问原则，老老实实做生意，其他的都无所谓，但是这个不可能长治久安。 </blockquote>
这样“简化”问题，其实是在逃避、偷懒，是在放弃对本质、对解释、对理解的追求。

反思的意思是，你要阻止自己，要把自己停住，不要线性地往前冲，想一想为什么今天要这么做，不能用别的方式。 </blockquote>
这个讲的不好。反思应该是一种隐藏起来的本能，如果没有反思，人类不可能存活下来，面对这样一个没有天敌，只能内部竞争的环境，我们应该做的是找回自己的反思本能。
作为中介的人类学</h2>

一个好的范例超过很多理论。 </blockquote>
再谈乡绅</h2>

要成为一系列的叙述，一个强大的自觉，讲出来之后，能让你觉得站在这个世界上有根基，如果外面来的东西你觉得不懂，你就有勇气说不懂，说不喜欢。所谓知识就是对世界上发生了什么事有根有据的了解，从这里开始，去观察，去沉淀，慢慢沉淀出底气。 </blockquote>
相当于有了自己的“根”，一个坐标系里的参考点，从此有了空间。

一本书最大的用处是给人改变，其次是给人思考，这本《把自己作为方法》二者皆有。里面最令人印象深刻的一句是：“不要拒绝理解”。这是我想法的盲区，也许在以后，我会再次翻看这本书，相信可以给我与此刻不一样的感受。

编程能力</h2>

个人展望</h3>

学习路径</h3>
预计到 2023 年年初具备职业开发者的素质，争取走技术移民/独立开发者的路子。</p>

执行情况</h4>
很遗憾，还未达成职业水平，而且在上班前也不会达到吧，去年的我想得太美了，完全没意识到学一年编程就达到职业水平是凡人不可能完成的任务。</p>

阶段计划</h2>

阅读计划</h3>

执行情况</h4>
第一本读了一半，这本书其实也就值得读一半；
走马观花地读完了第二本，实验和课后题完全没碰；
最后一本读了三分之一。</p>

工作计划</h3>

执行情况</h4>
走马观花地看了 1，发现没什么意思，2 的东西挺好，把边角料讲好也是本事；还有大致过了一遍 5 的视频字幕，对 OS 有了点概念，除此之外没看什么课程。</p>

执行情况</h4>
只看了 CS61B，还没看完。现在让我学的话我也只会学 CS61B，贪多嚼不烂。</p>

总结</h1>

笔记情况</h2>
2022 总结</p>
看得出我还是记了不少笔记的，可惜没啥时间消化它们。2023 继续坚持。</p>

项目计划</h2>

Markdown 格式化</h3>
为啥想做这个东西，每次整理笔记的时候格式总是一团糟，网上找到的实现也不符合我的需求，干脆自己写一个吧。</p>

Crane 语言</h3>
读完《Crafting Interpreter》总有种自己也写个语言的冲动，暂定名为 Crane，希望在 2023 年完成这个项目。</p>

whx's Blog

博客更新：从 zine 到 Zola

xv6 学习记录

从 Happened-before 说起（2）

从 Happened-before 说起（1）

AI 来了

2022 总结

2022 回顾 & 鞭尸</h1>

个人能力</h2>

记一次 Rust 探险

杭州游记

把自己作为方法

whx's Blog

博客更新：从 zine 到 Zola

xv6 学习记录

从 Happened-before 说起（2）

从 Happened-before 说起（1）

AI 来了

2022 总结

2022 回顾 & 鞭尸</h1>

个人能力</h2>

年初计划</h3> 深度阅读 10 本左右的各领域书籍</li> 争取输出自己的内容，读书笔记或者技术博客 5-6 篇</li> 练习英语阅读能力，之后是听和说</li>

执行情况</h3> 2022 阅读书籍</p>

编程能力</h2>

个人展望</h3>

学习路径</h3> 预计到 2023 年年初具备职业开发者的素质，争取走技术移民/独立开发者的路子。</p>

执行情况</h4> 很遗憾，还未达成职业水平，而且在上班前也不会达到吧，去年的我想得太美了，完全没意识到学一年编程就达到职业水平是凡人不可能完成的任务。</p>

阶段计划</h2>

阅读计划</h3>

年初计划</h4> 读完《计算机系统要素》</li> 读完《CSAPP》</li>

执行情况</h4> 第一本读了一半，这本书其实也就值得读一半； 走马观花地读完了第二本，实验和课后题完全没碰； 最后一本读了三分之一。</p>

工作计划</h3>

简单的计算机科学自学计划</h3> 年初计划</h4> 5-8 重点：</p>

年初计划</h4> 5-8 重点：</p>

执行情况</h4> 走马观花地看了 1，发现没什么意思，2 的东西挺好，把边角料讲好也是本事；还有大致过了一遍 5 的视频字幕，对 OS 有了点概念，除此之外没看什么课程。</p>

研究生工作 2022.2-</h3> 建立一个无人工厂：</del></p>

执行情况</h4> 只看了 CS61B，还没看完。现在让我学的话我也只会学 CS61B，贪多嚼不烂。</p>

总结</h1>

笔记情况</h2> 2022 总结</p> 看得出我还是记了不少笔记的，可惜没啥时间消化它们。2023 继续坚持。</p>

项目计划</h2>

Markdown 格式化</h3> 为啥想做这个东西，每次整理笔记的时候格式总是一团糟，网上找到的实现也不符合我的需求，干脆自己写一个吧。</p>

Crane 语言</h3> 读完 《Crafting Interpreter》总有种自己也写个语言的冲动，暂定名为 Crane，希望在 2023 年完成这个项目。</p>

记一次 Rust 探险

问题的起始</h2> 最近在看《The Book》，第 17 章的 17.3 节里面有这样一个细节：</p>

杭州游记

把自己作为方法

学习路径</h3>
预计到 2023 年年初具备职业开发者的素质，争取走技术移民/独立开发者的路子。</p>

执行情况</h4>
很遗憾，还未达成职业水平，而且在上班前也不会达到吧，去年的我想得太美了，完全没意识到学一年编程就达到职业水平是凡人不可能完成的任务。</p>

执行情况</h4>
第一本读了一半，这本书其实也就值得读一半；
走马观花地读完了第二本，实验和课后题完全没碰；
最后一本读了三分之一。</p>

执行情况</h4>
走马观花地看了 1，发现没什么意思，2 的东西挺好，把边角料讲好也是本事；还有大致过了一遍 5 的视频字幕，对 OS 有了点概念，除此之外没看什么课程。</p>

执行情况</h4>
只看了 CS61B，还没看完。现在让我学的话我也只会学 CS61B，贪多嚼不烂。</p>

笔记情况</h2>
2022 总结</p>
看得出我还是记了不少笔记的，可惜没啥时间消化它们。2023 继续坚持。</p>

Markdown 格式化</h3>
为啥想做这个东西，每次整理笔记的时候格式总是一团糟，网上找到的实现也不符合我的需求，干脆自己写一个吧。</p>

Crane 语言</h3>
读完《Crafting Interpreter》总有种自己也写个语言的冲动，暂定名为 Crane，希望在 2023 年完成这个项目。</p>