AI 圈每天都在冒新词。但你真的能准确说出每一个概念的确切含义吗？本文从最底层的工程视角出发，逐层拆解，帮你建立完整的 AI 技术认知体系。

LLM —— 一切的基础

LLM，全称 Large Language Model，中文译作大语言模型，简称大模型。

当前几乎所有主流大模型，底层都基于同一套架构——Transformer。这个架构最早由 Google 团队在 2017 年提出，对应的论文标题叫做《Attention Is All You Need》（注意力机制就是全部所需）。

虽然 Google 发明了这把火，但真正点燃全世界的是 OpenAI。

• 2022 年底，ChatGPT（GPT-3.5）横空出世，成为第一个真正达到"可用级别"的大模型；
• 2023 年 3 月，GPT-4 发布，把 AI 的能力天花板拉到了新高度。

GPT 系列是这轮 AI 浪潮的绝对引路人。时至今日，GPT 系列依然非常强大，如 GPT-4.5 仍是行业标杆之一。但如今 AI 赛道早已不是 OpenAI 一家独大，Claude、Gemini 等后起之秀都在各自擅长的领域与之同台竞技。

大模型是如何工作的？

大模型本质上是一个文字接龙游戏。

举个例子，你向大模型提问：「马克的视频怎么样」

1. 模型接收这句话，经过内部运算，预测下一个概率最高的词：「特」
2. 模型把「特」追加到输入后面，再预测下一个词：「别」
3. 如此循环，直到预测出特殊的结束标记

最终输出：「特别棒」

这就是大模型最底层的生成原理——一个词一个词地输出答案，因为它就是这么运作的。

Token —— 大模型的"最小单位"

大模型本质上是一个庞大的数学系统，接收的是数字，输出的也是数字，根本不认识人类书写的文字。

因此，在人类和大模型之间必须有一个中间人来做翻译，这个中间人就叫做 Tokenizer。它负责两件事：

• 编码（Encode）：把文字变成数字
• 解码（Decode）：把数字还原成文字

Token 化的过程

编码分两步：

$m$: 表示BloomFilter bit array的长度;
$k$: 表示hash函数个数;
$n$: 表示插入元素的个数;

假设hash函数以等概率选择bit array的下标，那么经过$k$个hash函数之后，某个bit位未被设置为1的概率为:

$$ (1 - \frac{1}{m})^k $$

在插入$n$个元素之后，某个bit位仍然没有被设置为1的概率为:

$$ (1 - \frac{1}{m})^{kn} $$

因此在插入$n$个元素之后，某个bit位被设置为1的概率为:

$$ p = 1 - (1 - \frac{1}{m})^{kn} $$

对于一个不存在于集合中的元素，如果要出现误判，那么意味着经过$k$个hash函数之后，生成的下标所在的bit位 都是1，其概率为:

$$ \epsilon = p^k = (1 - (1 - \frac{1}{m})^{kn})^k $$

接着来用欧拉公式来对上面的式子进行简化，已知欧拉公式可表示为:

$$ \lim_{m \to \infty}(1 + \frac{z}{m})^m = e^z $$

令$z = -1$

$$ \lim_{m \to \infty}(1 - \frac{1}{m})^m = e^{-1} $$

LLVM libFuzzer 是 LLVM 生态系统中的一个fuzzy test工具，用于自动化地发现软件程序中的漏洞和错误。它通过生成大量的随机输入数据并观察程序的行为来进行fuzzy test。 libFuzzer 是一个基于内存的fuzzy test引擎，使用 LLVM 的插桩技术和代码优化功能来提高测试效率和覆盖率。

以下是 libFuzzer 的一些功能特点：

1. 自动化fuzzy test：libFuzzer 提供了一种自动化的fuzzy test方法，可以生成大量的随机输入数据，并在每个输入上运行目标函数进行测试。它通过观察程序的崩溃、断言失败、未定义行为等反馈来发现潜在的问题。
2. 内存安全性：libFuzzer 通过使用 AddressSanitizer (ASan) 和 UndefinedBehaviorSanitizer (UBSan) 等工具来确保fuzzy test过程中的内存安全性。这有助于检测和报告内存错误、缓冲区溢出、使用已释放内存等问题。
3. 代码覆盖率分析：libFuzzer 使用 LLVM 提供的代码覆盖率分析技术，帮助确定已经执行过的代码路径和未执行的代码区域。这有助于评估测试的质量和覆盖范围，并帮助发现潜在的漏洞。
4. 快速收敛：libFuzzer 使用一种称为 “回退”（Backoff）的策略，以更快地收敛到程序中的漏洞。它会根据测试结果调整输入数据的变异程度，使得能够更快地发现问题并生成更有潜力的测试用例。
5. 灵活性和可定制性：libFuzzer 提供了多种选项和配置参数，使用户能够根据自己的需求进行定制。例如，可以设置最大测试时间、内存消耗限制、覆盖率报告等。
6. 多线程支持：libFuzzer 支持多线程执行，可以利用多核处理器并行进行fuzzy test，加快测试速度。

示例

下面是一个使用 libFuzzer 的简单示例

首先我们有一个 test_fuzzy.cpp:

 1#include <cstddef>
 2#include <cstdint>
 3
 4void DoSomethingWithData(const uint8_t* data, std::size_t size) {
 5  int* p = nullptr;
 6  if (size < 10) return;
 7  if (data[0] == 'h' && data[1] == 'e' && data[2] == 'l' && data[3] == 'l' && data[4] == '0') {
 8    *p = 42;
 9  }
10  return;
11}
12
13extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, std::size_t size) {
14  DoSomethingWithData(data, size);
15  return 0;
16}

使用 clang++进行编译：

Ref: https://www.tangramvision.com/blog/c-rust-generics-and-specialization

泛型入门：输入的类型

C++和 Rust 中的泛型都是一种将其他类型作为其定义的一部分的类型。泛型是通过在类型定义中指定占位符的一种方式，然后可以 使用更具体的类型来替换，例如在 C++中可以这定义一个泛型类型：

1template<typename T>
2struct MyArray {
3    T* raw_array;
4    std::size_t size;
5};

对于这个泛型结构而言，MyArray<int>和MyArray<std::string>是不同的类型。我们可以通过指定具体的T类型，来复用MyArray这个泛型结构体。这里的MyArray<T>就像一个“模板”一样。 泛型不仅仅局限于结构体，我们同样也能写出泛型函数：

1template<typename T>
2T timestwo(T number) {
3    return number + number;
4}

上面我们定义了一个非常简单的函数，用来将数值加倍。同理，用具体类型实例化的timestwo<int>和timestwo<double>也不是同一个函数。

而要在 Rust 中实现上面的函数，可能稍微复杂一点：

1use std::ops::Add;
2
3fn timestwo<T>(number: T) -> <T as Add>::Output
4where
5    T: Add + Copy,
6{
7    number + number
8}

很显然，上面 Rust 版本和 C++版本的实现相比看上去多了很多额外的语法。其中主要的区别是我们调用了特征边界检查，也就是T: Add + Copy， 或者用更通俗的话来说，T类型必须实现Add和Copy 特征(trait)。

Ref: https://www.tangramvision.com/blog/c-rust-interior-mutability-moving-and-ownership

C++和 Rust 中的不变性(constness)

值

Rust 和 C++有两个非常相似的概念，即 Rust 中的 mutability/immutability 和 C++中的 constness/non-constness. 在 Rust 中，一个给定的值要么是可变的(mutable)，要么是不可变的(immutable)，正如这些限定符名称所代表的含义，可变的值可以被修改，不可变的值不能被修改。 然而与 C++不同的是，Rust 中不可变的值可以被移动(move)，就像下面的代码实例那样：

1fn foo() {
2    let x = 1;
3    println!("{}", x)
4    let mut x = x;
5    x *= 10;
6    println!("{}", x);
7}

在 C++中，给定的值要么是常量(const)，要么是非常量(non-const)。但是 C++中的常量值不能被移动(move)。在 C++中，对一个 const 限定符修饰的值 进行std::move操作，实际上会触发拷贝构造，这一点在"Effective Modern C++“这本书中作者也有提到：

 1class Annotation {
 2public:
 3    explicit Annotation(const std::string text)
 4     : value(std::move(text)) //here we want to call string(string&&),
 5                              //but because text is const,
 6                              //the return type of std::move(text) is const std::string&&
 7                              //so we actually called string(const string&)
 8                              //it is a bug which is very hard to find out
 9    {}
10private:
11    std::string value;
12};

我们也可以自己写一段程序来验证一下：

 1// demo.c
 2#include <stdio.h>
 3
 4int func(int a) {
 5    return a + 1;
 6}
 7
 8int main(int argc, char* argv[]) {
 9    int (*f)(int) = func;
10    printf("%p\n", f);
11    return 0;
12}

上面的例子中，我们定义了一个函数func，然后通过函数指针f指向func，接着使用print函数打印指针变量f指向 的地址。代码平淡无奇，接着我们编译代码，然后使用objdump -D demo来查看生成的二进制结构如下：

10000000100003f34 <_func>:
2100003f34: ff 43 00 d1 	sub	sp, sp, #16
3100003f38: e0 0f 00 b9 	str	w0, [sp, #12]
4100003f3c: e8 0f 40 b9 	ldr	w8, [sp, #12]
5100003f40: 00 05 00 11 	add	w0, w8, #1
6100003f44: ff 43 00 91 	add	sp, sp, #16
7100003f48: c0 03 5f d6 	ret

上述结果是我在arm64-apple-darwin21.6.0环境下，使用clang 14.0编译出来的结果，gcc编译的结果稍微有点区别，但是对于本文分析问题影响不大。

splice函数通过重新排列链表指针，将一个std::list中的节点转移到另一个std::list中。在元素的转移过程中不会触发元素的拷贝或者移动。因此，调用splice函数之后，元素现有的引用和迭代器都不会失效。

下面是一个将listA中所有节点附加到listB的一个简单代码示例，转移的过程不会导致listA中元素的引用和迭代器失效:

 1// Note: c++17 required below. (For CTAD(Class template argument deducation))
 2std::list listA{1, 2, 3};
 3std::list listB{4, 5, 6};
 4
 5auto it = listA.begin();   // Iterator to 1
 6
 7// Append listA to listB
 8listB.splice(listB.end(), listA);
 9
10// All listA elements transferred to listB
11std::cout << listB.size() << " " << listA.size() << std::endl;   // 6 0
12
13// Prints Below: 4 5 6 1 2 3
14for (auto i : listB) {
15    std::cout << i << " ";
16}
17std::cout << std::endl;
18
19// Iterator still valid
20std::cout << *it << std::endl;   // 1

当然，我们也可以在不使用splice的情况下将一个 list 中的元素转移到另一个 list 中，但是需要将原 list 中的元素删除，并在目标 list 中插入新的元素。删除和新增元素对于较小的对象（例如 int）是可以接受的，但是对于较大的对象来说，由于需要调用拷贝/移动构造和析构函数，所以成本会很高。

shared_ptr是一种共享所有权的智能指针，它允许我们安全地访问和管理对象的生命周期。shared_ptr的多个实例通过共享控制块结构来控制对象的生命周期。 控制块维护了引用计数(reference count)，弱引用计数(weak count)和其他必要的信息，通过这些信息，控制块能够确定一个对象在内存中是否可以被安全销毁。

当使用原始指针构造或者初始化一个shared_ptr时，将会创建一个新的控制块。为了确保一个对象仅由一个共享的控制块管理，必须通过复制已存在的shared_ptr对象来创建一个新的shared_ptr实例，例如：

1void good()
2{
3  auto p{new int(10)}; // p is int*
4  // create additional shared_ptr from an existing shared_ptr
5  std::shared_ptr<int> sp1{p};
6  // sp2 shares control block with sp1
7  auto sp2{sp1};
8}

而使用指向已由shared_ptr管理的对象的原始指针来初始化另一个shared_ptr时，会创建一个新的控制块来管理该对象， 这样同一个对象就同时被多个控制块管理，这会导致 undefined behavior，例如：

1void bad()
2{
3  auto p{new int(10);};
4  std::shared_ptr<int> sp1{p};
5  std::shared_ptr<int> sp2{p}; // Undefined behavior!
6}

通过原始指针的方式实例化shared_ptr很容易产生同一个原始指针实例化多个shared_ptr这样的编码疏忽，从而造成严重后果。 因此尽量使用std::make_shared或者std::allocate_shared来降低出错的可能性。毕竟除非有人刻意为之，否则我们似乎很难遇到或写出这样的代码：

c++11 对智能指针做了很大的优化，废弃了 c++98 中的auto_ptr，引入了三种新的智能指针：unique_ptr，shared_ptr，weak_ptr。 本文将针对unique_ptr的一些使用技巧做一些整理和归纳。在正式开始之前，我们首先来回顾一下unique_ptr的特点：一个unique_ptr对象内包含一个原始指针，该unique_ptr对象负责管理原始指针的生命周期。 一个unique_ptr对象始终是其关联的原始指针的唯一拥有者。

在了解了unique_ptr的特点之后，我们来具体看看日常开发中unique_ptr的一些使用场景和技巧。

一些场景

本地对象指针

在开发中，我们经常会遇到或者写出类似于下面这样的逻辑：

 1void somefunc() {
 2    Object obj = new Object;
 3    // ...
 4    if (/* event 1 */) {
 5        delete obj;
 6        return;
 7    }
 8
 9    if (/* event 2 */) {
10        delete obj;
11        return;
12    }
13    delete obj;
14}

对于这样的代码，写起来很麻烦，看上去也及其丑陋。以前我们常用的一种优化手段就是使用goto，而在 c++11 之后，我们有了一种更加优雅简洁的方式，来对上面的代码进行优化，那就是使用unique_ptr:

Expression Templates 是一种 C++ 模板元编程技术，它通过在编译时构建按需执行的计算表达式，从而生成高效的代码。简单来说，通过 Expression Templates，我们可以实现惰性求值和消除因为中间结果而创建的临时变量。

一个常规示例

我们构造了一个MyVector类，并且重载了MyVector的+和*操作符，实现两个MyVector中相同下标元素的+和*操作。 对于这样的需求我们很容易写出形如下面代码的一个简单的实现：

 1#include <cassert>
 2#include <iostream>
 3#include <vector>
 4
 5template<typename T> class MyVector
 6{
 7public:
 8    MyVector(const std::size_t n)
 9        : vec_(n)
10    {}
11    MyVector(const std::size_t n, const T initvalues)
12        : vec_(n, initvalues)
13    {}
14
15    std::size_t size() const { return vec_.size(); }
16
17    T operator[](const std::size_t i) const
18    {
19        assert(i < size());
20        return vec_[i];
21    }
22
23    T& operator[](const std::size_t i)
24    {
25        assert(i < size());
26        return vec_[i];
27    }
28
29private:
30    std::vector<T> vec_;
31};
32
33template<typename T> MyVector<T> operator+(const MyVector<T>& a, const MyVector<T>& b)
34{
35    assert(a.size() == b.size());
36    MyVector<T> result(a.size());
37    for (std::size_t i = 0; i < a.size(); ++i) {
38        result[i] = a[i] + b[i];
39    }
40    return result;
41}
42
43template<typename T> MyVector<T> operator*(const MyVector<T>& a, const MyVector<T>& b)
44{
45    assert(a.size() == b.size());
46    MyVector<T> result(a.size());
47    for (std::size_t i = 0; i < a.size(); ++i) {
48        result[i] = a[i] * b[i];
49    }
50    return result;
51}
52
53template<typename T> std::ostream& operator<<(std::ostream& os, const MyVector<T>& vec)
54{
55    std::cout << '\n';
56    for (std::size_t i = 0; i < vec.size(); ++i) {
57        os << vec[i] << ' ';
58    }
59    os << '\n';
60    return os;
61}
62
63int main(int argc, char* argv[])
64{
65    MyVector<double> x(10, 5.4);
66    MyVector<double> y(10, 10.3);
67    auto             ret = x + x + y * y;
68    std::cout << ret << std::endl;
69    return 0;
70}

这个实现平淡无奇，相信每个人都能随手写出来。在godbolt上编译成汇编来分析：

在 c++中为了实现多态，使用了一种动态绑定的技术，这个技术的核心就是虚函数表(virtual table)。下面就简单的说明一下基于虚表的动态绑定的原理，从而更好的与静态多态做比较。

在 c++中，每个包含虚函数的类都有一个虚表。我们来看下面这个类：

 1// demo.cpp
 2class A
 3{
 4public:
 5    virtual void vfunc1();
 6    virtual void vfunc2();
 7    void         func1();
 8    void         func2();
 9
10private:
11    int m_data1, m_data2;
12};

我们可以借助编译器来查看上述类的对象布局：

1# 使用llvm编译工具
2clang -Xclang -fdump-record-layouts -stdlib=libc++ -c demo.cpp # 查看对象布局
3clang -Xclang -fdump-vtable-layouts -stdlib=libc++ -c demo.cpp # 查看虚表布局
4
5# 使用gcc编译工具
6g++ -fdump-lang-class demo.cpp

这里为了便于分析，使用 clang 打印的结果来具体说明：

下面可以通过一个简单的例子来看看constexpr if的用法：

 1#include <iostream>
 2#include <type_traits>
 3
 4template<typename T> auto getValue(T t)
 5{
 6    if constexpr (std::is_pointer<T>::value) {
 7        return *t;
 8    } else {
 9        return t;
10    }
11}
12
13int main(int argc, char* argv[])
14{
15    int  a = 10;
16    int* b = &a;
17    getValue(a);
18    getValue(b);
19    return 0;
20}

其实和普通的条件判断区别不大，只不过constexpr if中的条件是常量表达式，可以在编译时确定条件表达式的结果，从而选择编译对应的分支代码。 我们可以将上述代码编译成汇编来进一步分析：

基本用法

Designated Initialization 是聚合初始化(Aggregate Initialization)的一种形式。 在 c++20 中，聚合类型(Aggregate types)是指：

• 数组类型
• 具备如下特性的 class 类型：
• • has no private or protected direct non-static data members
• • has no user-declared or inherited constructors
• • has no virtual, private, or protected base classes
• • has no virtual member functions

c++20 中的 Designated Initializers 的用法跟 c99 非常相似：

1struct Points
2{
3    double x{0.0};
4    double y{0.0};
5};
6
7const Points p{.x = 1.1, .y = 2.2};
8const Points o{.x{1.1}, .y{2.2}};
9const Points x{.x = 1.1, .y{2.2}};

优点

使用 Designated Initializers 最大的好处就是能够提升代码的可读性。

做存储开发，一定会经常涉及到 IO 相关的操作。而现在的高级编程语言，往往会帮助我们屏蔽 IO 操作的底层细节，虽然这样能降低开发门槛，提升效率，但是却也导致我们对 IO 底层操作实现的理解不够系统和深入。 所以呢，我一直想抽时间来系统整理一下 Linux IO 涉及的系统调用，以及相互之间的区别和联系，以加深对 IO 操作的理解。

IO 操作

fwrite

fwrite 是 c 语言标准库中的文件写入函数，其作用是向指定的文件中写入若干数据。调用 fwrite 实际上是将数据写入到了 c 标准库的 IO Buffer 中。

mmap

mmap 将一个文件或者其它对象映射进内存。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。mmap 在用户空间映射调用系统中作用很大。

fflush

fflush 就是将 c 标准库中的 IO Buffer 中的数据写入到参数 stream 指定的文件中。

fsync

fsync 系统调用就是将内核缓冲区中的数据同步到存储介质(如硬盘)。也可以在 open 文件的时候通过开启O_SYNC来开启同步 I/O.

各 IO 操作的区别与联系

std::tuple 简介

std::tuple是一个具有固定大小，包含不同类型值的集和。与之相似的是std::pair，只不过std::pair只能容纳两个元素， 而std::tuple可以容纳许多元素：

1std::tuple<int, double, const char*> tup {42, 10.5, "hello"};
2
3// or with CTAD(class template argument deduction), C++17:
4std::tuple deducedTup {42, 10.5, "hello"}; // 自动推导类型

访问std::pair中的元素只需要访问.first和.second成员即可:

1std::pair p = {10, 10.5};
2p.first += 10;

然而std::tuple并没有类似于.first .second的成员，标准库中我们只能通过std::get来直接访问其中的元素:

 1std::tuple tp {1, 2, "hello", "world", 10.5};
 2
 3// by index
 4std::get<0>(tp) += 10;
 5std::get<1>(tp) *= 20;
 6std::cout << std::get<2>(tp) << '\n'; // hello
 7std::cout << std::get<3>(tp) << '\n'; // world
 8
 9// by type
10std::cout << std::get<double>(tp) << '\n'; // 10.5

如何遍历 tuple

对 tuple 有了初步的了解，也知道了如何去获取 tuple 中的元素，那么接下来我们就来一步步构造对 tuple 遍历的方法。

std::string_view是 c++17 中新增的一种类型。其核心理念是，能够让我们在传统的 C++03 风格的具体性和泛型编程之间找到一个很好的折衷点。 在 C++17 标准之前，我们通常只能在粗糙的不严谨的模板实现和相对严谨但是有着冗长约束的模板之间做出选择。举个简单的例子：

 1// c++03 style
 2class Widget
 3{
 4    std::string name_;
 5
 6public:
 7    void setName(const char* new_name);
 8    void setName(const std::string& new_name);
 9};
10
11// 不正确的欠约束的模板
12class Widget
13{
14    std::string name_;
15
16public:
17    template<class T> void setName(T&& new_name);
18};
19
20// 正确的但是约束但滑稽冗长的模板
21class Widget
22{
23    std::string name_;
24
25public:
26    template<class T, class = decltype(std::declval<std::string&>() = std::declval<T&&>()) >>
27                              void setName(T&& new_name);
28};

而有了 string_view 之后，以上代码就可以简化成如下：

要谈论 LevelDB 的 Compaction 就不得不从 LevelDB 的整个数据写入流程入手。LevelDB 的基本写入流程大致为：

1. 数据先写入到 WAL 日志中，做持久化
2. 然后数据同步到mutable memtable中
3. 当mutable memtable大小达到Options.write_buffer_size设置的大小时，就会变成immutable memtable，并且创建一个新的mutable memtable
4. 后台的 Compaction 线程会把immutable memtabledump 成 sstable 文件，并设置于 Level 0 层
5. 当 Level i 达到一定条件后，就会和 Level i + 1 层的 sstable 进行合并，从而触发 Compaction 过程，并在 Level n + 1 层生成一个新的 sstable 文件

2. Compaction 分类

在 LevelDB 中，Compaction 大体上可以分为两类，分别是：

• immutable memtable compaction，也叫做minor compaction，指的是将immutable memtabledump 到 sstable 文件的过程
• sstable compaction，也叫做major compaction，指的是 sstable 文件之间的合并过程

而对于sstable compaction又可以细分为三种：

简介

• 在可能存在叛军的情况下，采用合适的通讯协议，让多个将军达成共识，执行统一的作战计划
• 二忠一叛难题
• 它是分布式领域最复杂的容错模型
• 莱斯利·兰伯特（Leslie Lamport）The Byzantine Generals Problem

二忠一叛难题

• 总共有三个将军，其中一个作为指挥官
• 通过信使相互传递作战指令，进攻或者撤退
• 所有忠诚的将军必须执行统一的作战计划，忠诚的将军必须执行忠诚的指挥官发布的指令
• 假如 LIEUTENANT2 叛变，LIEUTENANT1 收到的作战指令就是“进攻，撤退”
• 假如 COMMANDER 叛变，LIEUTENANT1 和 LIEUTENANT2 收到的作战指令都是“进攻，撤退”

口信消息型解法

• 叛变人数为 m 需要已知
• 则所有参与者的人数至少为 3m+1
• 第一轮由指挥官发送作战指令
• 第二轮由各位将军相互发送指令
• 收到指令的将军按照少数服从多数的原则执行指令
• 按照这个公式，前面的例子叛军为 1 人的情况，则需要 1 个指挥官和 3 个将军

假如 LIEUTENANT3 叛变了，那么首先指挥官向各位将军发送“进攻”的指令，由于 3 号将军叛变了，所以最终 1 号将军收到的指令是 2 个进攻，1 个撤退，2 号将军同样收到 2 个进攻，1 个撤退，这样忠诚的将军将会执行一致的指令

我们 laser 存储为了更好的跟引擎对接，适应其他团队的技术生态，决定开发一套 golang 的公共库来给大家使用。于是我们在公司私有的 gitlab 上新建了一个项目:git.yourcomp.com/ad/ads_core/adgo，并且我们想使用单一的 codebase 来管理所有的公共 library.

而且，为了更好的管理模块，我们统一使用了 go mod。

按照平时我们在 github 上拉取 go library 的惯例，我本以为直接使用go get git.yourcomp.com/ad/ads_core/adgo/xxx就能直接拉取到相应的模块了，然而在开发完功能测试的时候却发现，事实并不是想象中那样。

遇到的问题和解决方案

1. 仓库问题

执行go get后，实际上会请求"https://git.yourcomp.com/ad/ads_core/adgo?go-get=1"这个地址，如果使用-insecure选项，则会请求"http://git.yourcomp.com/ad/ads_core/adgo?go-get=1"，正常情况下回返回meta tag：

1<html>
2  <head>
3    <meta
4      name="go-import"
5      content="git.yourcomp.com/ad/ads_core git http://git.yourcomp.com/ad/ads_core.git"
6    />
7  </head>
8</html>

这是 go remote import 的协议，meta tag 的格式一般为

下面我们来定义 lisp.h 头文件

 1#ifndef LISP_H_OTE1HWPK
 2#define LISP_H_OTE1HWPK
 3
 4#include <stdio.h>
 5#include <stdlib.h>
 6
 7#define define(ret, name, args, block) \
 8    ret name args { return block; }
 9
10#define if(expr, block1, block2) \
11    expr ? block1 : block2
12
13#define eq(a, b) \
14    a == b
15
16#define neq(a, b) \
17    a != b
18
19#define sub(a, b) \
20    a - b
21
22#define mul(a, b) \
23    a * b
24
25#define add(a, b) \
26    a + b
27
28#define div(a, b) \
29    a / b
30
31#endif /* end of include guard: LISP_H_OTE1HWPK */

然后来用类似于 lisp 的语法编写一段求阶乘的代码：

1define(int, factorial, (int n),
2       if(eq(n, 0),
3          1,
4          mul(n, factorial(sub(n, 1)))))
5
6define(int, main, (void),
7       (printf("10! = %d\n", factorial(10)), EXIT_SUCCESS))

编写 Makefile:

1CFLAGS = -Wall -include "lisp.h"
2
3TARGET=factorial
4
5all:
6	gcc -o $(TARGET) $(TARGET).c $(CFLAGS)
7
8clean:
9	rm -f $(TARGET)

编译并运行：

1liubang@venux-dev:~$ make
2gcc -o factorial factorial.c -Wall -include "lisp.h"
3liubang@venux-dev:~$ ./factorial
410! = 3628800

 1// random.c
 2#include <stdio.h>
 3#include <stdlib.h>
 4#include <time.h>
 5
 6int main() {
 7    srand(time(NULL));
 8    int i = 10;
 9    while (i--) printf("%d\n", rand() % 100);
10    return 0;
11}

编译运行：

 1liubang@venux-dev:~$ gcc random.c -o random
 2liubang@venux-dev:~$ ./random
 344
 446
 597
 651
 762
 876
 992
1076
1138
1210

这个程序每次运行的结果都是不一样的，现在我们希望我们能够在不修改源码的情况下，控制程序的输出结果，例如我希望这段程序运行的结果是 每次都能输出 10 个 10。由于不能修改源码，或者我们根本没有源码，面对这样一个编译后的可执行二进制文件，想要修改程序的运行结果，可能显 得有些困难。然而，如果能够善用动态连接器的话，这都不是问题。

BDD(Behavior Driven Development)，行为驱动开发，是一种敏捷软件开发的技术，它鼓励软件项目中的开发者、QA 和非技术人员或商业参与者之间的协作。

BDD 的重点是通过与利益相关者的讨论取得对预期的软件行为的清醒认识。它通过用自然语言书写非程序员可读的测试用例扩展了测试驱动开发方法。行为驱动开发人员使用混合了领域中统一的语言的母语语言来描述他们的代码的目的。这让开发者得以把精力集中在代码应该怎么写，而不是技术细节上，而且也最大程度的减少了将代码编写者的技术语言与商业客户、用户、利益相关者、项目管理者等的领域语言之间来回翻译的代价。

具体怎么操作

结合我们项目开发使用的 spring boot 2.x，下面我们来具体说明如何在实际项目中使用 BDD。

依赖的包

 1<cucumber.version>4.2.5</cucumber.version>
 2
 3...
 4
 5<dependency>
 6    <groupId>io.cucumber</groupId>
 7    <artifactId>cucumber-junit</artifactId>
 8    <version>${cucumber.version}</version>
 9    <scope>test</scope>
10</dependency>
11
12<dependency>
13    <groupId>io.cucumber</groupId>
14    <artifactId>cucumber-java</artifactId>
15    <version>${cucumber.version}</version>
16    <scope>test</scope>
17</dependency>
18
19<dependency>
20    <groupId>io.cucumber</groupId>
21    <artifactId>cucumber-spring</artifactId>
22    <version>${cucumber.version}</version>
23    <scope>test</scope>
24</dependency>

定义启动文件

BDD 其实也是依赖 junit，然后调用Cucumber的 Runner 来运行相应的测试。

这篇文章主要是为了帮助大家熟悉 POSIX 线程库以及在实际开发中使用它的特性。我们会具体讲解如何利用这个线程库定义的不同工具 来解决编程中的问题。当然这里隐含了一个假设，就是读者已经了解过并行编程（或者多进程）的相关概念，如果没有这些背景知识 的话，读者可能会感觉到很难理解。不过也没关系，我的另一篇教程里边有专门为只具备线性编程思维的读者提供了对并行编程理论 和相关术语的讲解。

同样的，我假设聪明的你已经熟悉了异步编程模型，那些经常使用桌面环境的人会更容易去接受多线程编程的理念。

当我们谈到 POSIX 线程的时候，肯定会有人心生疑惑：“我们应该使用哪个标准下的 POSIX 线程？”。由于 POSIX 线程标准已经修订了好 多年，人们会发现，依据不同标准的实现有不同的函数集，不同的默认值和不同的细微差别。所以在此说明的是，本教程使用的是 v0.5 版的 Linux 内核中的线程库，使用其他操作系统和使用其他版本的读者，需要阅读一下你们对应的系统文档来同本文中的实例进行对应。同时，有些示例代码中使用到了阻塞式的系统调用，它们不能再用户级的线程库中很好的工作（参考另一篇文章：parallel programming theory tutorial 来获取详细信息）。好了，说了那么多，主要是为了能保证文章中的示例代码能够在其他系统中正常使用，从而提高跨平台性。

什么是线程？为什么要使用线程？

线程是一个迷你版的进程，它们拥有自己的栈，能够执行给定的一段代码。但是不同于进程的是，线程通常与其他线程共享记忆体（而 每个进程都拥有一个独立的记忆体区域）。一个线程组就是一个执行相同代码的线程的集合，他们共用记忆体，可以访问相同的全局变 量，拥有同样的文件描述符等等，他们以并行的方式执行（可能是时间片的方式，或者对于多核心系统，他们会真正平行执行）。

使用线程组而不是普通顺序执行程序的好处是多个操作可以同时进行，当一些事件产生的时候，他们能立马被处理（例如：如果我们有 一个线程处理用户接口，另一个线程处理数据库查询，那么我们可以在处理很多用户查询的同时，依然能够响应用户的输入）。

使用线程组而不是进程组的好处是线程间的上下文切换要比进程间的上下文切换要快很多（上下文切换是指系统从一个正在运行的线程或进程切换到去执行另一个线程或进程）。此外，线程间的通信也远远比进程间通信要高效很多。

线程编程有利也有弊，由于线程组共享记忆体，如果一个线程破坏了记忆体，那么其他线程也要受到牵连。但是进程就不同了，操作系 统会将进程之间隔离开，如果一个进程破坏了它的记忆体，那么其他进程不会受到影响。使用进程的另一个好处是，不同的进程可以运 行在不同的机器上，但是线程必须运行在同一台机器上（至少通常情况下是这样的）。

创建和销毁线程

当一个多线程程序启动执行到main()函数的时候，就会有一个线程运行，这是一个全程线程（full-fledged thread，或者叫主线程），如果想创建一个新的线程，程序中需要使用pthread_create()函数

 1#include <stdio.h>
 2#include <pthread.h>
 3
 4void *do_loop(void *data)
 5{
 6    int i; // counter, to print numbers
 7    int j; // counter, for delay
 8    int me = *((int *)data);
 9    for (i = 0; i < 10; i++) {
10        for (j = 0; j < 50000; j++) // delay loop
11            ;
12        printf("'%d' - Got '%d'\n", me, i);
13    }
14
15    // terminate the thread
16    pthread_exit(NULL);
17}
18
19int main(int argc, char *argv[])
20{
21    int       thr_id;    // thread ID for the newly created thread
22    pthread_t p_thread;  // thread's structure
23    int a = 1;           // thread 1 identifying number
24    int b = 2;           // thread 2 identifying number
25
26    // create a new thread that will execute 'do_loop()'
27    thr_id = pthread_create(&p_thread, NULL, do_loop, (void *)&a);
28
29    // run 'do_loop' in the main thread as well
30    do_loop((void *)&b);
31
32    return 0;
33}

上述这段代码需要特殊说明的是：

前一些日子，我发现了一个叫做Pux的路由库，这个路由库声称自己比现有的路由要快很多，为了实现这个特点，该库使用了 C 语言编写了 PHP 扩展。

然而，当我瞅了几眼它的代码后，我非常怀疑这个库在路由过程中做了错误的优化，而且我能够很容易在不适用扩展的情况下做出更高性能的实现。 当我在看了 benchmarking 代码后更加确定了我的怀疑，因为我发现这里仅仅只是对及其确定的单个路由做了测试。

为了进一步研究这个问题，我写了一个轻量的路由库：FastRoute。这个库中实现的分发过程接下来我会具体描述。为了给出一些前期印象，这里先给出一个 同 Pux 库的 benchmark 结果：

 11 placeholder  | Pux (no ext) | Pux (ext) | FastRoute
 2-----------------------------------------------------
 3First route    | 0.17 s       | 0.13 s    | 0.14 s
 4Last route     | 2.51 s       | 1.20 s    | 0.49 s
 5Unknown route  | 2.34 s       | 1.10 s    | 0.34 s
 6
 79 placeholders | Pux (no ext) | Pux (ext) | FastRoute
 8-----------------------------------------------------
 9First route    | 0.22 s       | 0.19 s    | 0.20 s
10Last route     | 2.65 s       | 1.78 s    | 0.59 s
11Unknown route  | 2.50 s       | 1.49 s    | 0.40 s

这个 benchmark 使用了 100 个路由，分别对最好和最坏的情况做了测试。而且分两个方面进行：一个是只包含一个占位符的路由，另一个是包含 9 个占位符的路由。整个过程 重复了上千次。

C++提供了很多库：

1. 标准 ANSI C 库都可以移植到 C++中。不同于 ANSI C 库的是，C++中需要在库名前加上"c"前缀，而且去掉".h"，例如<cmath>对应于 C 语言就是<math.h>，<cstdlib>对应于 C 语言的<stlib.h>
2. C++新增的库，例如 <iostream>，<iomanip>，<string>，<fstream>，<sstream>
3. C++STL：包括容器，迭代器，算法和函数对象
4. Boost C++库

1.1 C 库和相关头文件

• <cstring>：待会解释
• <cmath>：数学计算相关的库
• <cstdlib>：通用工具，例如异常（abort, exit, EXIT_SUCCESS, EXIT_FAILURE）；环境相关（getenv）；动态内存管理（malloc, free, calloc, realloc），字符解析（atoi, atof, atol, strtod）， 伪随机序列生成（rand, srand, RAND_MAX）；数组搜索和排序（bsearch, qsort）
• <cctype>：字符类型检测（isalpha, isdigit, isalnum, isspace, isupper, islower, isblank, iscntrl, isgraph, isprint, ispunct, isxdigit）和字符转换（toupper, tolower）
• <climits>, <cfloat>：Size and limit of integer types (INT_MAX, INT_MIN, UINT_MAX, CHAR_BIT; and SHRT_XXX for short, LONG_XXX for long, LLONG_XXX for long long, CHAR_XXX for char) and floating-point types (DBL_MIN, DBL_MAX, DBL_DIG, DBL_MIN_EXP, DBL_MAX_EXP; and FLT_XXX for float, LDBL_XXX for long double)
• <ctime>：time, difftime, clock, gmttime, localtime, and etc.
• <cstdio>: C’s IO operations (scanf, printf, fscanf, fprintf, fopen, fclose, etc)
• <cassert>, <cerrno>, csignal>: 断言和错误
• <clocale>：本地化
• <cstdbool>, <cstdint>, <cstddef>, <cstdarg>:
• <cuchar>, <cwchar>, <cwcchar>: Unicode 字符

1.2 C++库和相关头文件

• <ios>, <iostream>, <istream>, <ostream>, <fstream>, <sstream>
• <iomanip>
• <string>
• <regex>
• <random>
• <limits>
• <stdexception>, <exception>
• <complex>, <tuple>, <valarry>
• <locale>
• <typeinfo>
• <chrono>
• 其它：<codecvt>, <new>, <ratio>, <system_error>, <type_traits>

1.3 C++ STL 和相关头文件

STL 主要由以下头文件提供：

1.1 字符类型库：头文件"cctype"

在头文件<cctype>（相当于 C 语言中的<ctype.h>），包含了一下字符处理函数：

2. 字符串：C-String 和 string 类

回顾一下，我们知道 C++支持两种类型的字符串：

操作符重载就像函数重载那样，同一个函数名可以因为参数不同而同时存在很多版本。

1. string 类中重载的操作符

C++的"string"类中重载了以下操作符来作用于"string"对象：

• 字符串比较操作(=,!=,>,<,>=,<=)：例如，使用str1 == str2来比较两个"string"对象
• 流插入和取出操作(«,»)：例如，你可以使用cout << st1和cin >> str2来输出/输入"string"对象
• 字符串连接(+,+=)：例如，str1 + str2，将两个"string"对象合并成一个新的"string"对象，str1 += str2将str2追加到str1后
• 字符索引或下标([])：例如，你可以使用str[n]来获取下标为 n 的字符；或者str[n] = c来修改下标为 n 处的字符。需要注意的是’[]‘操作符不会 做边界检测，也就是说，你需要自己保证下标不会超出边界，你可以使用"string"类的at()函数来做边界检测
• 赋值(=)：例如，str1 = str2，将str2赋值给str1

示例代码：

 1#include <iostream>
 2#include <iomanip>
 3#include <string>
 4
 5using namespace std;
 6
 7int main(int argc, char *argv[]) {
 8	string msg1("hello");
 9	string msg2("HELLO");
10	string msg3("hello");
11
12	cout << boolalpha;
13	cout << (msg1 == msg2) << endl;
14	cout << (msg1 == msg3) << endl;
15	cout << (msg1 < msg2) << endl;
16
17	string msg4 = msg1;
18	cout << msg4 << endl;
19
20	cout << (msg1 + " " + msg2) << endl;
21	msg3 += msg2;
22
23	cout << msg3 << endl;
24
25	cout << msg1[1] << endl;
26	cout << msg1[99] << endl;
27
28	return 0;
29}

2. 用户自定义操作符重载

2.1 “operator"函数

为了实现操作符重载，我们需要使用一种特殊的函数形式，叫做操作符函数。操作符函数形如：“operator Δ()"，Δ 就是将要被重载的操作符。

我们对传递数值或变量给函数都很熟悉，除了传递变量，我们还能传递类型给模板。传递类型就是大家所熟知的泛型编程，因为 我们可以用泛型编写程序，而用特定的类型调用。

泛型编程的目的是为了编写的程序不依赖于数据类型。在 C 语言中，所有的代码都需要绑定到确定的数据类型，这样写的代码只能对特定的数据类型起作用。 而模板可以让我们实现泛型编程。你可以将类型作为参数来构建模板函数和类模板。当你的算法需要作用于多种数据类型的时候，模板就显得及其有用了。

C++的标准模板库(STL)提供了一些常用的容器类模板的实现，例如vector，可以用来存放所有类型的元素。

2. 示例：STL 中的 vector 类模板

C/C++中的内置数组有一些缺点：

1. 它的大小是固定的，需要在声明的时候确定大小，不支持动态声明。你不能在执行期给数组扩容；
2. 数组不提供下标边界校验，你可以使用超出边界的下标
3. 你需要自己实现数组比较，和赋值操作

C++提供了一个vector类模板，作为标准模板库(STL)的一部分。vector被定义在<vector>头文件中，属于std命名空间。vector 是最常用的 STL 类，它能够取代数组，并且支持动态分配空间和一些其它操作（例如比较和赋值）。

vector 是一个类模板，它可以被特定类型的实例化，形如：vector<int>, vector<double>, vector<string>。同一个模板能够用于多种类型，而不必为每种类型都写一套实现。

 1#include <iostream>
 2#include <vector>
 3#include <string>
 4
 5using namespace std;
 6
 7void print(const vector<int> &v);
 8
 9int main(int argc, char *argv[]) {
10	vector<int> v1(5); // Create a vector with 5 elements.
11
12	// Assign values into v1, using array-like index []
13	// You can retrieve the size of vector via size()
14	for (int i = 0; i < v1.size(); i++) {
15		v1[i] = (i + 1) * 2;
16	}
17
18	// Print vector content, using at()
19	for (int i = 0; i < v1.size(); i++) {
20		cout << v1.at(i) << " ";
21	}
22	cout << endl;
23
24	vector<int> v2;
25	// Assign v1 to v2 memberwise
26	v2 = v1;
27	for (int i = 0; i < v2.size(); i++) {
28		cout << v2[i] << " ";
29	}
30	cout << endl;
31
32	// Compare 2 vectors memberwise
33	cout << boolalpha << (v1 == v2) << endl;
34
35	// Append more elements - synamically allocate memory
36	v1.push_back(80);
37	v1.push_back(81);
38	for (int i = 0; i < v1.size(); i++) {
39		cout << v1[i] << " ";
40	}
41	cout << endl;
42
43	vector<string> v3;
44	v3.push_back("a for apple");
45	v3.push_back("b for boy");
46	for (int i = 0; i < v3.size(); i++) {
47		cout << v3[i] << " ";
48	}
49
50	cout << endl;
51
52	return 0;
53}

说明：

1.1 术语

超类（基类）和子类（派生类）：在面向对象程序设计中，我们通常使用继承来避免代码冗余。在 C++中，继承的语法规则如下：

1class SubclassName : inheritance-access-specifier SuperclassName {
2	......
3};

子类继承了父类所有的成员，子类也可以定义自己的构造器和成员。

访问标识符：C++支持三种访问标识符：private，public和protected。一个类的 public 成员变量、成员函数，可以通过类的成员函数、类的实例变量进行访问。 一个类的 protected 成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。一个类的 private 成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。

继承访问标识符：public 继承不改变基类成员的访问权限，private 继承使得基类所有成员在子类中的访问权限变为 private，protected 继承将基类中 public 成员变为子类的 protected 成员，其它成员的访问 权限不变。 基类中的 private 成员不受继承方式的影响，子类永远无权访问。

1.2 一个示例

MovablePoint.h

 1#ifndef MOVING_POINT_H
 2#define MOVING_POINT_H
 3
 4#include "Point.h"
 5
 6class MoviablePoint : public Point {
 7private:
 8	int xSpeed, ySpeed;
 9
10public:
11	MovablePoint(int x, int y, int xSpeed = 0, int ySpeed = 0);
12	int getXSpeed() const;
13	int getYSpeed() const;
14	void setXSpeed(int xSpeed);
15	void setYSpeed(int ySpeed);
16	void move();
17	void print() const;
18}
19#endif

MovablePoint.cpp

回到之前版本的"Time"类，假设我们想增加链式操作，例如t.nextSecond().nextSecond().print()，我们就需要让nextSecond()返回this的一个引用。

Time.h

1class Time {
2private:
3	......
4public:
5	Time &nextSecond(); // Return a reference to "this" instance
6	......
7}

在函数原型中，我们申明了一个nextSecond()的成员函数，返回Time对象的引用。返回的引用可以用来继续调用成员函数。

Time.cpp

 1// Increase this instance by one second and return this instance by reference.
 2Time &Time::nextSecond() {
 3	if (++second == 60) {
 4		second = 0;
 5		if (++minute == 60) {
 6			minute = 0;
 7			if (++hour = 24) {
 8				hour = 0;
 9			}
10		}
11	}
12
13	return *this; // Return this instance by reference
14				  // "this" is a pointer to this instance. *this refers to the instance.
15}

C++有一个关键字"this"，它保存了一个指向当前实例的指针。也就是说，*this指的是当前实例。

指针之所以这么强大，是因为它允许你通过地址来访问和操作对应记忆体中存储的内容。但是指针也很难被驾驭，使用好的话确实能够大大提升性能，而用的 不好的话，也会导致很多问题，例如著名的内存泄漏和缓冲区溢出，这些 bug 会致使系统发生紊乱。一些新的编程语言（例如 Java 和 C#），将指针从它的语法 中去掉，通过提供自动内存管理的方式来避免使用指针导致的许多问题。

虽然你在编写 C/C++代码的时候可以不使用指针，但是在学习 C/C++的时候很难不提及指针。指针也许不是为新手和笨蛋而设计的。

1. 指针变量

计算机记忆体位置有一个地址，对应地址处保存数据。记忆体地址通常是一个数字（一般用十六进制表示），这个数字很难被程序员直接使用。通常一个地址位置 的容量是 8-bit（也就是 1-byte），里面可以存储整数，实数，字符或者字符串，这完全取决于程序员如何解析。

为了减轻程序员使用数字地址和解析数据的负担，早期的编程语言（例如 C 语言）中产生了一种新的变量——这种变量是一个被命名了的变量的位置，它可以存储一个特定类型的值。 取代数字地址的是用名字（或者标识符）直接关联到确定的地址上，而且变量类型（如int, double, char）与之关联，从而简化了对数据的解析。

每个内存地址占 8 位（也就是 1 个字节），一个 4 个字节的int值需要 4 个内存位置。一个 32 位的系统通常使用 32 位的地址。同样的，存储这个 32 位的地址也需要 4 个内存位置。

下面的插图形象的描绘了计算机内存地址，内存中数据，变量名，变量类型以及变量值之间的关系。

1.1 指针变量

指针变量（简称指针）基本上跟其他变量一样，都可以用来存放数据，但是跟普通变量不同的是，普通变量存储的是数值，而指针存放的是内存地址。

1.2 申明指针

指针在使用前必须先申明。申明指针的语法是在指针名前加上一个*符号。指针必须跟类型关联。

1type *ptr;
2// or
3type* ptr;
4// or
5type * ptr;

例如：

假如你想组装一台电脑，你会去硬件商店购买主板、处理器、内存条、硬盘、机箱、电源，然后将它们组装在一起，然后打开电源，电脑就能运行。 你不用考虑主板是 4 重板还是 6 重板，硬盘是什么尺寸，内存是哪里生产的诸如此类的问题。你只需要将这些硬件单元组合在一起，就能期待电脑能够运行。 当然，你需要保证你有正确的接口，比如，如果你的主板只支持 IDE 接口，而你需要购买一个 IDE 的硬盘而不是 SCSI 硬盘，又例如你需要选择一个合适速率的 内存。即便如此，将硬件组件组装成一台机器也没有任何难度。

同样的，一辆车也是由多个部分组装起来的，例如底盘、车门、引擎、车轮、刹车和传动装置。这些组件都是可复用的。比如车轮，就能够被用于很多辆同型号的骑车上。

像电脑和汽车这样的硬件能够用可复用的部分组装起来。那么软件是否也是如此呢？我们是否能够将不同地方的程序片段“组装”起来，然后期待程序能正常运行呢？ 答案显然是 no！跟硬件不同的是，很难从软件片段中“组装”一个应用。自从计算机 60 年前问世以来，人们写了大量的程式码。然而，对于每一个新的应用程序，我们都需要 重新造轮子。

为什么要重新造轮子呢？

1.1 传统的面向过程的编程语言

传统的面向过程的编程语言（例如 C 和 Pascal）在创建可重用组件方面遇到了一些显著的缺陷：

1. 程序是由函数组织起来的。函数通常是不可重用的，我们很难将一个函数直接拷贝到别的地方去使用，因为函数很有可能引用了头文件，或者全局变量，或者调用了其他函数。 换句话说，函数不能很好的封装成一个独立的可重用单元。

2. 面向过程的语言不适合高层抽象来解决现实生活中的问题。例如 c 程序使用"if-else", “for-loop”, “array”, “function”, “pointer"等结构，这些结构很低阶而且很难抽象形如 Customer Relationship Management (CRM) 系统或者电脑足球游戏。

简而言之，传统的面向过程的编程语言将数据结构和算法单元分开了。

1.2 面向对象的编程语言

面向对象的编程语言就是被设计来克服这些问题的。

1. OOP 的基础单元是类。类将静态属性和动态行为封装在一起，同时指定一些公开的接口来供人使用。由于相比于函数，类有很好的封装性，所以很容易重用。换句话说，类将数据和算法结合在了一起。

2. 面向对象的编程语言为解决现实问题的高阶抽象提供了保证。面向过程的编程语言迫使人们把注意力放在计算机结构（如：内存，位，字节，数组）上，而不是放在要解决的问题本身。面向对象的编程语言 能够让我们更专注于问题本身，使用程序对象来表示和抽象问题中的各种实体。

举个例子，假设你要写一个足球游戏，很难用面向过程的语言建立模型。但是使用 OOP，可以很容易将现实事物同程序之间建立模型：

• Player：属性包含 name, number, location 等待，操作有 run, jump, kick-the-ball…
• Ball:
• Reference:
• Field:
• Audience:
• Weather:

最重要的是，这其中的一些类（例如：Ball 和 Audience）可以在其他程序中复用。

写这篇文章的目的是基于 php7，阐述 Zend Virtual Machine 的内部实现。这不是一篇综合描述，我将尽可能地覆盖到所有重要的部分和细节。

本文的描述对象是 php7.2 版本，但是几乎所有的特性都已经应用在了 php7.0/7.1 中了。然而，它们同 php5.x 系列 VM 的不同之处同样也很重要，我会很有耐心的同步描述。

这篇文章主要是从指令的角度来阐述，只有在末尾花了少量篇幅描述了 C 语言实现 VM 的细节。但是在文章开始之前，我想先提供一些实现 VM 的主要代码文件：

• zend_vm_def.h: VM 定义文件
• zend_vm_execute.h: 生成的 VM
• zend_vm_gen.php: VM 生成脚本
• zend_execute.c: 大多数直接支持的代码

Opcodes

首先我们来聊聊 opcode。“Opcode"是用来表示整个 VM 指令集（包括操作数）的，但是也可能仅仅就是指“真实的”操作码，这些操作码是一个很小的整数用来区分不同的指令类型。其具体的含义需要结合代码的上下文才能清楚。在程式码中，指令通常被称作"oplines”。

下面是zend_op的结构

 1struct _zend_op {
 2    const void *handler;
 3    znode_op op1;
 4    znode_op op2;
 5    znode_op result;
 6    uint32_t extended_value;
 7    uint32_t lineno;
 8    zend_uchar opcode;
 9    zend_uchar op1_type;
10    zend_uchar op2_type;
11    zend_uchar result_type;
12};

由此看来，opcodes 本质上就是一个“三地址码”格式的指令。有一个opcode代表指令的类型，有两个输入操作数op1和op2和一个输出操作数result。

前言

PHP 和线程，单凭这简短的几个字，就足以写一本书。像往常一样，我们不会这么做，但是会给出一定程度上跟这个话题相关的信息与细节。让我们从一些人在谈论这个话题时通常感到的困惑开始，PHP 不是一种线程语言， PHP 的内核没有使用线程，而且 PHP 天生也不允许用户层代码通过任何方式使用多线程作为并发机制。

因此 PHP 跟其他一些技术有很大的区别，例如 Java。Java 不仅自身使用了大量的线程，它还允许用户通过编程来是用线程。然而，PHP 不适用线程是有它的原因的。

PHP 内核没有使用线程，主要是为了简化开发。当你读到下一节的时候，你就会了解到线程并不是一个能使任何程序都能更快运行的魔法技术。是不是听起来很像是在推销不是吗？但是我们不是推销，而是谈论技术，而且 我们很清楚我们在说什么。因此 PHP 引擎目前没有使用多线程，也许将来会使用。但是使用多线程在编程上会引发很多问题，例如程序运行结果不是你所期待的等等。主要的困难是跨平坦的多线程编程，其次就是资源共享和 锁的管理，再次就是并不是所有的程序都能够被转化成多线程程序。PHP 的设计主要在 2000 前后，在那个时候，多线程编程并不是很广泛和成熟，PHP 引擎开发工程师决定创造一个完全没有线程的单片机引擎（当然他们也没有 足够的能力去驾驭一个稳定的跨平台的多线程引擎）。

PHP 用户层代码也不允许使用线程，因为那不是 PHP 期待你的代码运行的方式。PHP 是一个"发送并忘记(fire-and-forget)“型的语言，你应该尽可能快的处理完请求，然后释放，然后接着处理下一个请求。PHP 被设计作为一种 胶水语言：你不用处理可能使用到线程的复杂任务，而是访问快速而且已经准备好的资源，将它们粘合到一起，然后再返回给用户。通过 PHP，无论什么可能花费比通常时间多的时间的任务，都不能用 PHP 来处理。这就是为什么 在 PHP 中我们通常使用基于消息队列的系统(Gearman, AMQP, ActiveMQ 等等)来异步处理一些耗时任务。正如 Unix 看待事物的方式：“开发小而完备的工具，然后将他们连接在一起”。因此 PHP 的设计不是允许大规模的并行，而是 其他专门的技术–是用正确的工具来解决特定的问题。

线程的简介

让我们来快速的介绍下线程。注意，我们不会阐述太多细节的东西，对于你想深入了解关于线程的任何细节，都可以在相关书籍和站点上找到。

线程是进程中的轻量的事务处理单元，注意，一个进程可以产生多个线程，一个线程必须有且只能属于一个进程。进程是操作系统中的基本工作处理单元。在多 CPU 的机器上，不同的 CPU 将会平行工作，这样对于计算能力的提升会 有很大的好处。如果进程 A 和 B 都准备被执行，而且两个 CPU（或者两个 CPU 核心）也都有空闲的负载，那么进程 A 和 B 将会同时被执行。因此，计算机将能高效的在一个单位时间内同时进行多个运算，我们称之为“并行”(parallelism)。

从“中的一个例子说起

1(*(void(*)())0)()

下面我们来一步步分析：

我们知道变量的声明方式为：

1int a;

函数的声明方式为：

1int fn();

指针的声明方式为：

1int *a = 10;

函数指针的声明方式为：

1int (*fn)(); //fn 是一个指向返回int型的函数的指针

函数指针的调用方式：

 1typedef int (*fn_type)();
 2
 3int fn() {
 4    return 0;
 5}
 6
 7fn_type a = fn;
 8
 9printf("%d\n", a());
10//或者
11printf("%d\n", (*)a());

最简单的类型转换：

在之前的文章中，我们已经实现了一些 object handlers 来将我们的 ArrayBuffer 整合到 php 中。但是美中不足的是，我们的 ArrayBufferView 并不支持迭代器操作。也就是它不能像 php 中的数组那样使用foreach来遍历。 那么，我们接下来就来看看迭代器在内核中是如何实现的，并且给我们的 ArrayBufferView 也增加一个迭代器。

get_iterator handler

内核中的迭代器跟用户端的IteratorAggregate接口功能是一样的。一个具有迭代功能的类都有一个get_iterator处理器，它会返回一个zend_object_iterator *类型的结构，该结构定义如下（位于 phpsrc/Zend/zend_iterators.h 中）：

1struct _zend_object_iterator {
2    void *data;
3    zend_object_iterator_funcs *funcs;
4    ulong index; /* private to fe_reset/fe_fetch opcodes */
5};

其中的index成员就是内核中用以实现foreach的，它的值会在每次迭代后增加。funcs成员包含了不同的迭代操作：

 1typedef struct _zend_object_iterator_funcs {
 2    /* release all resources associated with this iterator instance */
 3    void (*dtor)(zend_object_iterator *iter TSRMLS_DC);
 4
 5    /* check for end of iteration (FAILURE or SUCCESS if data is valid) */
 6    int (*valid)(zend_object_iterator *iter TSRMLS_DC);
 7
 8    /* fetch the item data for the current element */
 9    void (*get_current_data)(zend_object_iterator *iter, zval ***data TSRMLS_DC);
10
11    /* fetch the key for the current element (optional, may be NULL). The key
12     * should be written into the provided zval* using the ZVAL_* macros. If
13     * this handler is not provided auto-incrementing integer keys will be
14     * used. */
15    void (*get_current_key)(zend_object_iterator *iter, zval *key TSRMLS_DC);
16
17    /* step forwards to next element */
18    void (*move_forward)(zend_object_iterator *iter TSRMLS_DC);
19
20    /* rewind to start of data (optional, may be NULL) */
21    void (*rewind)(zend_object_iterator *iter TSRMLS_DC);
22
23    /* invalidate current value/key (optional, may be NULL) */
24    void (*invalidate_current)(zend_object_iterator *iter TSRMLS_DC);
25} zend_object_iterator_funcs;

这些处理器跟Iterator接口中的抽象方法类似，只不过名字不同罢了。唯一没有对应用户端接口的是invalidate_current，它可以被用来销毁当前的key/value。 然而这个操作几乎不会被用到，通常foreach也不会取调用它。

在前面的博文中，已经介绍过一些 object handlers 了，也特别介绍了如何通过指定 handlers 来创建一个自定义的结构和使用clone_obj来对自定义的结构进行克隆操作。 然而，这只是开始：在 php 中，几乎所有的对象操作，都可以通过 object handlers 来实现，而且所有的魔术方法和魔术接口在内核中都是实现了对应的 object handler。此外， 一些 handlers 并没有开放给用户端的 php，例如，内部类可以自定义类的比较操作，而使用 php 代码是无法实现的。

由于 php 中有很多不同的 object handlers，这里只挑几个来讨论，其它的只给出简单的说明。

概述

下面列举出 php 中主要的 26 个(php5.6 中为 28 个)object handlers（位于 phpsrc/Zend/zend_object_handlers.h），并给出简要的说明。

1zval *read_property(zval *object, zval *member, int type, const struct _zend_literal *key TSRMLS_DC)
2void write_property(zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC)
3int has_property(zval *object, zval *member, int has_set_exists, const struct _zend_literal *key TSRMLS_DC)
4void unset_property(zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC)
5zval **get_property_ptr_ptr(zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC)

上述 handlers 分别表示__get，__set，__isset，__unset方法。get_property_ptr_ptr等同于__get返回一个引用类型。zend_literal *key作为这些函数的参数 起到优化作用，例如它包含了一些将属性名进行 hash 计算的结果。

1zval *read_dimension(zval *object, zval *offset, int type TSRMLS_DC)
2void write_dimension(zval *object, zval *offset, zval *value TSRMLS_DC)
3int has_dimension(zval *object, zval *member, int check_empty TSRMLS_DC)
4void unset_dimension(zval *object, zval *offset TSRMLS_DC)

上述了几个 handlers 就是内核用以实现ArrayAccess接口的。

ArrayBuffer 又叫二进制数组，是一个用来表示通用的，固定长度的二进制数据缓冲区。你不能直接操纵 ArrayBuffer 的内容， 而是创建一个表示特定格式的 buffer 的类型化数组对象（也叫做数据视图对象）来对 buffer 的内容进行读写操作。

我最早了解 ArrayBuffer 是从 JavaScript 开始的，具体的用法和 api 可以参考JavaScript 标准库－－ArrayBuffer

那么接下来，我们就给 PHP 扩展一个简单的 ArrayBuffer，顺便巩固一下php 扩展开发之自定义对象的存储。

定义 ArrayBuffer 的数据结构和相关 handlers

ArrayBuffer是一个非常简单的对象，它只需要申明并存储一个buffer和它的长度即可：

1typedef struct _buffer_object {
2    zend_object std;
3    void *buffer;
4    size_t length;
5} buffer_object;

接下来我们来实现它的create和free handlers，有了前面的基础，这个实现也是及其简单的：

 1static void linger_array_buffer_free_object_storage(buffer_object *intern TSRMLS_DC)
 2{
 3	zend_object_std_dtor(&intern->std TSRMLS_CC);
 4	linger_efree(intern->buffer);
 5}
 6
 7zend_object_value linger_array_buffer_create_object(zend_class_entry *class_type TSRMLS_DC)
 8{
 9	zend_object_value retval;
10	buffer_object *intern = emalloc(sizeof(buffer_object));
11	memset(intern, 0, sizeof(buffer_object));
12
13	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
14	object_properties_init(&intern->std, class_type);
15
16	retval.handle = zend_objects_store_put(
17			intern,
18			(zend_objects_store_dtor_t) zend_objects_destroy_object,
19			(zend_objects_free_object_storage_t) linger_array_buffer_free_object_storage,
20			NULL
21			TSRMLS_CC
22			);
23
24	retval.handlers = &linger_array_buffer_handlers;
25	return retval;
26}

从上面的代码中可以看到，我们并没有在create_object中申请buffer的空间，而这步操作将会在__construct中来实现，因为buffer的长度会作为构造函数的参数传递过来。

对于 php 扩展开发，很多人可能已经不那么陌生了，zend 引擎为了们提供了非常丰富了函数和 macro，来帮助我们很快速的创建一个标准的 php 类，然而，当我们在使用自定义的数据结构(struct)， 并想把我们自己定义的数据结构封装成 php 的类的时候可能就会有些困惑，因为我们都知道 php 中的所有变量都是通过 zval 来存储的，而我们自定义的数据结构要怎样才能和 zval 实现完美的对接呢？ 以前我通常采用的一种方式就是使用 zend 引擎提供的资源类型，因为资源类型的封装中包含了通用的数据类型，而且有很丰富的函数来操作资源，所以使用起来很简单也很方便。然而，强大的 zend 引擎真的没有其他方式扩展数据结构了吗？当然不是！下面就来介绍一个更加优雅的方式。要弄明白，首要要搞清 php 内核是如何创建对象的。

如何创建一个对象

我们首先来探讨下如何创建一个 PHP 对象。为此我们将会用到object_and_properties_init之类的一些宏。

 1// 创建一个SomeClass类型的对象，并且把properties_hashtable中的变量作为其属性值
 2zval *obj;
 3MAKE_STD_ZVAL(obj);
 4object_and_properties_init(obj, class_entry_of_SomeClass, properties_hashtable);
 5
 6// 创建一个没有属性的对象
 7zval *obj;
 8MAKE_STD_ZVAL(obj);
 9object_init_ex(obj, class_entry_of_SomeClass);
10// = object_and_properties_init(obj, class_entry_of_SomeClass, NULL)
11
12// 创建一个stdClass的对象
13zval *obj;
14MAKE_STD_ZVAL(obj);
15object_init(obj);
16// = object_init_ex(obj, NULL) = object_and_properties_init(obj, NULL, NULL);

在上面的例子中，最后一种情况下，当你创建一个stdClass的对象后，通常将会给它添加属性。这时如果使用 zend_update_property之类的函数，是不起作用的，取而代之的是add_property宏函数：

哈希表又叫散列表，是实现字典操作的中有效数据结构。通常来说，一个 hash table 包含了一个数据，其中的数据通过 index 来访问。 而 hash table 的基本原理就是通过 hash 函数建立起所有可能的 index 与其对应的位置的联系。一个 hash 函数接收一个 key，返回其 hash code， key 的类型是可变的，而 hash code 是一个整型。

由于计算一个 hash 值和通过 index 访问一个数据都是常量级的时间复杂度，所以我们可以通过这中特性实现常量级时间复杂度的查找。 如果一个 hash 函数能够保证不会有两个不同的 key 生成相同的 hash 值，那么这样的 hash table 就被称为是直接定址。然而，这只是一想法而已， 实际上这种 hash table 在现实中却是不常用的。

Chained Hash Table

链式 hash 表从本质上来讲，就是一个存放了一组链表的数组。每个链表可以看做是一个槽，我们把元素通过 hash 函数找到一个 hash 值，然后把元素的值 放入到数组中与改 hash 值对应的槽中。

Collision Resolution

当有两个 key 被 hash 到了同一个位置，就会产生冲突。链式 hash 表有一种简单的冲突解决办法：当冲突产生时，元素被简单的放在同一个槽里。这样做可能带来的问题就是， 如果在同一个位置上出现很多冲突，这个槽就会变得越来越长，这样当我们访问这个槽中的元素的时候，所花的时间也就会越来越长。

在 c 语言中，结构体(struct)是一种复合数据类型，用来将一系列相同或不同类型的变量聚集在同一个内存区间内并赋予同一个名字，使得通过一个指针就能访问集合中的所有成员。结构体中可以包含许多简单或符合数据类型，因此从内存分配上看，有点类似数组，而从变量组织上看，又类似于面向对象编程语言中的类。

定义 struct

定义一个 struct 非常简单，使用struct关键字即可。

1struct student {
2    char *name;
3    int age;
4};

struct 的初始化

通常有四种常用的 struct 初始化方式。

１．定义并初始化

1struct {
2    char *ext;
3    char *filetype;
4} extensions[] = {
5    {"gif", "image/gif"},
6    {"jpg", "image/jpg"}
7};

２．按照成员声明的顺序初始化

记得去年我曾经用 C 语言写过一个 PHP 的 md5 扩展函数，那么今天就花一点点时间用 JNI 来实现一遍吧。

不过这里可要提前声明了，虽然是实现 md5 函数，但是这里并不会从头写 md5 算法，而是投机取巧使用到了 linux 内核提供的crypto库。

废话不多说，首先来写一个 Java 类

MyString.java

 1public class MyString {
 2    static {
 3        System.loadLibrary("mymd5");
 4    }
 5
 6    private String value;
 7
 8    public native String md5();
 9
10    public MyString(String value) {
11        this.value = value;
12    }
13}

然后生成头文件，并实现 c 代码：

JNI 中定义了一下类型来对应到相应的 Java 的数据类型:

1. Java 基本数据类型: jint,jbyte,jshort,jlong,jfloat,jdouble,jchar,jboolean分别对应 Java 中的int,byte,short,long,float,double,char和boolean。

2. Java 引用类型： jobject对应java.lang.object。同时也定义了下列子类型：

• jclass对应java.lang.Class
• jstring对应java.lang.String
• jthrowable对应java.lang.Throwable
• jarray对应 Java 中的数组。Java 中的数组由 8 种基本数据类型和一个Object类型派生二来，所以 JNI 中也存在jintArray,jbyteArray,jshortArray,jlongArray,jfloatArray,jdoubleArray, jcharArray,jbooleanArray和jobjectArray

native 函数接收和返回上述的 JNI 类型数据。如果 native 函数需要操作它自己的数据类型(如 c 语言中的 int, char *)，那么就需要在 JNI 类型和本地类型之间做相应的转换。

简而言之，native 函数的编写流程大致为：

1. 通过 Java 程序接收 JNI 类型的参数
2. 将接收的 JNI 类型转换成本地类型
3. 完成相应的操作
4. 创建一个需要返回的 JNI 类型的对象，然后将返回的数据 copy 到要返回的对象中
5. 返回

从上述流程可以看出，编写 JNI 程序主要的挑战在于数据类型之间的转换，然而 JNI 中提供了很多转换函数来帮助我们完成相应的操作。

JNI 是一个 c 语言的接口，c 语言并不支持 OOP 的特性(严格的说，OOP 是一种理念，这里只是从语言本身来说 c 语言不支持面向对象，实际上用 c 语言也可以写出面向对象风格的程序！)，所以他们之间并不是真的通过对象来传递。

1 简介

有时候，使用 native code(c/c++)来克服 Java 中的内存管理和性能的局限性是很有必要的。Java 支持 native codes，被称作 Java Native Interface(JNI)。

JNI 非常难，毕竟它牵涉到了两种编程语言。假设聪明的你对 Java 和 C/C++以及 GCC 编译器已经有所了解。那么下面就一起来一步步学习 JNI 吧。

2 开始

2.1 用 c 语言实现第一个 JNI 程序

Step1: 创建一个名字为 JNITest.java 的文件

 1public class JNITest {
 2    static {
 3        System.load("/home/ubuntu/workspace/java/jni/mynativelib.so");
 4    }
 5
 6    //申明一个无参的native方法，而且返回空
 7    public native void greet();
 8
 9    //测试
10    public static void main(String[] args) {
11        JNITest test = new JNITest();
12        test.greet();
13    }
14}

首先用静态代码块加载本地动态链接库"mynativelib.so"。对于静态代码块，我相信写过 Java 的你应该非常清楚，它只会在类被加载的时候执行一次。这个动态链接库会被添加到 Java 的 library path（保存在 Java 系统变量 java.library.path）中，如果加载失败，就会抛出UnsatisfiedLinkError异常。也可以使用 JVM 启动参数来加载该动态链接库到 Java 的 library path 当中：

1 简介

malloc是干什么的？如果你连这个名字都没听过，那么你应该先去了解 Unix 环境下的 c 语言开发，然后再来阅读。对一个程序员而言，malloc是一个在 c 语言中用来分配内存的函数，但是大多数人并不知道它背后真正的原理，甚至有些人认为malloc是 c 语言的关键字或者认为它是系统调用。事实上，malloc是一个再简单不过的函数而已，而且只需要很少的操作系统相关知识就可以让我们彻底理解它的原理。

下面来一步步的实现一个简单的malloc函数，从而帮助我们理解其背后运作的原理。因为仅仅作为说明原理之用，所以这里实现的malloc不会太高效，但是足以说明原理。

什么是 malloc

malloc(3)是一个用来分配内存块的标准的 c 语言库函数。它遵循以下规则：

• malloc至少分配所需字节数的内存；
• malloc返回其所分配内存空间(程序可以成功读写的空间)的指针；
• 一块内存一旦被malloc分配，其他malloc调用不能再分配该内存块的任何部分，除非指向该内存块的指针被释放掉；
• malloc应该是可控的：他必须能够很快完成分配并返回；
• malloc同时应该提供重新分配内存块大小和释放内存的功能

malloc函数必须遵循以下原型：

1void *malloc(size_t size);

其中size是所需要的内存大小。如果失败（没有足够的内存空间可以分配），应该返回NULL。

2 堆，brk 和 sbrk 系统调用

在开始实现第一个malloc函数之前，需要了解内存在大多数多任务操作系统中是如何管理的。这里我们只是做出一个抽象的解释，从大体上去帮助理解，至于很多细节，它们都依赖操作系统原理和硬件相关的知识。

2.1 进程的内存

每个进程都有自己的虚拟地址空间被 MMU（Memory Management Unit, 内存管理单元）(和内核)动态的转换到物理内存地址空间。这部分空间被划分成了几个部分，我们需要了解的是至少有一部分空间存放代码，一个用来存放局部变量的栈，一部分用来存放常量和全局变量的空间，以及程序的无组织空间我们称之为堆。

堆是一个连续的（依据虚拟地址而言）内存空间，它有三个边界：一个起始点，一个最大限度边界（通过 sys/ressource.h 中的 getrlimit(2)函数和 setrlimit(2)函数来管理）和一个被称为break的结束点。break标记了隐射内存空间的结束，也就是说，虚拟地址空间部分对应着真实的内存空间。下图表示内存组织结构

要想实现一个malloc函数，我们需要知道堆的起始点和 break 的位置，然后我们来移动 break。要做到这些，就需要用到两个系统调用，brk和sbrk。

2.2 brk(2)和 sbrk(2)

我们可以在这些系统调用的文档中看到相关描述：

当今世道，各种高级语言百花齐放。然而会有人发出这样的疑问–计算机真的能够识别这么多语言吗？稍微有点常识的人都知道，这显然是不可能滴！在计算机的世界里，他们能够直接识别的只有机器语言。然而，由于机器语言对人类不够友好，所以人们才发明了汇编，c，Java…许许多多的人类易读的编程语言，所以我个人对编程语言的理解一直是其实他们就是机器语言的语法糖，而编程语言的创造过程，就是定义一种合理的，没有二义性的语法规则，然后就是通过直接或间接的方式实现该语法到机器语言的转换过程。既然是这样的话，那么我们就很容易想到，计算机语言是一个自我完善的过程：首先我们定了一种非常简单的 x1(这里只是用来举例说明，有没有 x 语言有待考证)语言，然后用机器语言实现了这个非常简单的 x1 语言的编译器，创造了 x1 语言，实现了非常简单的新特性，然后我们再用 x1 语言(相对于机器语言较高级)实现了另一些新的特性的 x2 语言的编译器，创造了 x2 语言，…，如此下去，人们创造了汇编语言，从而创造了 c 语言，接着创造了世界上最好的语言 PHP(不知道是不是真的，反正大家都习惯这么说)。 在各种高级语言越来越强大的今天，我们可能很难再会去接触最原始的东西，高度封装确实提高了生产力，降低了学习成本，但是也使得现代程序员将太多精力花在了各种说明书上，而不清楚其本质。 毕业一年多，工作了一年多，对于计算机编程有了自己的看法，不再像在大学的时候认识的那样肤浅，反而觉得大学中学习的知识才是真正的干货，不禁感叹曾经浪费掉了大好光阴。好在陶渊明有词云：“悟已往之不谏，知来者之可追”。 闲暇之余，扒开 PHP(这里之所以是 PHP 并不因为他是世界上最好的语言，只是因为我目前从事的是 PHP 开发的工作而已)源码，了解了其内部构造和实现原理，百看不一练。今天就初步学习 yacc/lex 了，记录在我的博客中，以便以后翻阅巩固。

过程简述

一般来说编程语言的解释执行过程如下：

ONE. 词法分析 将源代码拆分成若干 Token 的过程

TWO.语法分析 将 Token 构建成 Syntax Tree 的过程

THREE.生成执行码 生成可执行文件

yacc（Yet Another Compiler Compiler）

下面是 wikipedia 中对 yacc 的描述

Yacc is a computer program for the Unix operating system. It is a Look Ahead Left-to-Right (LALR) parser generator, generating a parser, the part of a compiler that tries to make syntactic sense of the source code, specifically a LALR parser, based on an analytic grammar written in a notation similar to Backus–Naur Form (BNF). Yacc itself used to be available as the default parser generator on most Unix systems, though it has since been supplanted as the default by more recent, largely compatible, programs.

]]>https://blog.liubang.cc/posts/php/2017-03-09-php%E6%89%A9%E5%B1%95%E5%BC%80%E5%8F%91%E4%B9%8Bcall-user-func%E5%8E%9F%E7%90%86%E5%92%8C%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0%E7%9A%84%E5%AE%9E%E7%8E%B0/Thu, 09 Mar 2017 00:00:00 +0000https://blog.liubang.cc/posts/php/2017-03-09-php%E6%89%A9%E5%B1%95%E5%BC%80%E5%8F%91%E4%B9%8Bcall-user-func%E5%8E%9F%E7%90%86%E5%92%8C%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0%E7%9A%84%E5%AE%9E%E7%8E%B0/函数调用

很多时候，我们需要通过函数名来调用函数，并传递参数，或者把匿名函数作为函数的参数传递，实现回调。当我们在遇到这样的需求的时候，用 php 代码实现起来肯定是非常容易和简单的。但是，当我们在用 c 语言编写 php 扩展的时候，如何来实现这样的功能呢？下面就一起来深入了解 php 内核，看看如何实现。

在 Zend 引擎中，给我们提供了zend_call_function,call_user_function以及call_user_function_ex函数来帮助我们实现函数调用。在zend_API.h文件中，我们可以看到如下函数原型的声明：

1ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC);
2ZEND_API int call_user_function(HashTable *function_table, zval **object_pp, zval *function_name, zval *retval_ptr, zend_uint param_count, zval *params[] TSRMLS_DC);
3ZEND_API int call_user_function_ex(HashTable *function_table, zval **object_pp, zval *function_name, zval **retval_ptr_ptr, zend_uint param_count, zval **params[], int no_separation, HashTable *symbol_table TSRMLS_DC);

从函数的参数上来看，显然zend_call_function需要的参数很少，而其他两个都需要一堆参数，所以，我们可能会想，达到相同的效果为什么参数上有如此大的区别，于是带着这个疑问我们来解刨zend_fcall_info结构体。同样在zend_API.h中会看到如下结构体的定义：

 1typedef struct _zend_fcall_info {
 2        size_t size;
 3        HashTable *function_table; //函数表
 4        zval *function_name;	   //函数，可以是函数名，也可以直接是匿名函数本身
 5        HashTable *symbol_table;   //符号表
 6        zval **retval_ptr_ptr;	   //返回值
 7        zend_uint param_count;     //参数个数
 8        zval ***params; 		   //参数，数组
 9        zval *object_ptr;		   //调用对象方法时候需要传调用的对象
10        zend_bool no_separation;
11} zend_fcall_info;

不难发现，原来是把相关字段封装到了结构体中了，所以显得参数数量少，实际上该有的都有。

]]>