机器学习近年来的快速发展促进了传统嵌入式视觉系统的变革，众多传统嵌入式视觉应用采用机器视觉和传感器融合技术后都在发生巨变。在 All programmable 技术和器件的全球领先企业赛灵思发布面向广泛视觉导向机器学习应用的名为 reVISION™堆栈解决方案的时候，赛灵思公司战略与市场高级副总裁 Steve Glaser 通过一个视频向我们展示了这样一个视觉导向的机器学习所推动的嵌入式视觉系统未来世界。点击查看原视频那么，赛灵思重磅发布的这个 reVISION™堆栈和嵌入式视觉系统的开发有什么关系，又有着什么样的市场价值和意义呢？从传统的嵌入式视觉系统到视觉导向的自动化系统转变的三大需求随着人工智能技术的发展，许多传统的嵌入式视觉系统正在逐步向利用机器学习和传感器融合的视觉导向系统应用转变，赛灵思 reVISION™所瞄准的，就是视觉导向的半导体市场。赛灵思认为这个市场占据大约三分之二的应用和三分之一的总市场容量。许多传统嵌入式视觉系统正在逐步向利用机器学习和传感器融合的视觉导向系统应用转变在 Steve Glaser 看来，从传统的嵌入式视觉系统到视觉导向的自主系统，其实质就是后者可以实现三大使命：下一代视觉导向系统的应用使命第一、系统要能够智能高效地快速响应速度极快的确定性系统响应时间是十分必要的。以汽车识别潜在的碰撞并采取刹车为例，ADAS 实际应用需要实时进行响应，甚至有时要具备可预测性。快速响应可以轻松实现安全刹车，避免碰撞，反之则会造成碰撞，带来安全隐患。这不但要求系统从感应到处理、分析、决策、通信一列过程高效推进，同时还要高效部署最新的机器学习技术。第二、 系统要可以灵活地升级到最新算法和传感器就灵活性而言，为了能够用尖端神经网络和机器学习推断效率部署最佳系统，工程师必须能够在整个产品的产品生命周期同时优化软硬件。通过统计可以看出，机器学习领域最近两年的科技发展十分迅猛。许多新的神经网络随着新技术的出现不断发展，也大幅提高了的部署效率。系统升级速度需要跟上神经网络演进的速度而且，人工智能革命加速了传感器技术在不同领域的发展演进，也要求更高水平的传感器融合，以整合不同类型的传感器，以便在大环境下构建全面而完整的系统环境和对象视图。系统升级需要跟上传感器融合的演进的速度鉴于神经网络和相关算法的快速变化以及传感器的快速发展，可重配置性也就应运而生，使得软硬件系统不受传感器配置标准以及未来部署的限制，这满足了灵活性的需求。第三、系统可以支持随时与其他机器和云相连接。由于许多新系统都连接到了一起（比如物联网），因此需要与传统的已有设备通信，要与未来推出的新设备通信，还要能够进行云端通信。赛灵思全可编程技术的独特优势Steve Glaser 称，赛灵思全可编程的解决方案拥有独特的优势，可以全部满足以上自主系统需要实现的三大需求，而且比其它替代方案拥有显著的和可测量的优势。通过高效的推断和控制，赛灵思实现了传感器的最快响应时间，支持最新的神经网络，算法和传感器的可重构性，并支持与传统或新机器、网络和云的任意连接。实际上，赛灵思全可编程解决方案在嵌入式视觉世界早已经被全球数百家用户所青睐。迄今为止，也就是在 reVISION™发布之前，全球已经有 23 家汽车制造商在 85 款不同车型的 ADAS 系统中部署了赛灵思先进的嵌入式视觉系统，另外还有数百家嵌入式视觉用户在其他数千种应用中也部署了赛灵思的先进嵌入式视觉系统。其中至少有 40 家已经在开发或部署机器学习技术以大幅提高系统的智能。大多数的视觉用户都看准了 Zynq® All Programmable SoC 和 MPSoC 的应用。Steve Glaser 同时也承认，赛灵思方案虽然是打造下一代机器学习导向自主系统的理想选择，但是长期以来，这种方案还只属于那些拥有一定的硬件或者 RTL 设计基础工程师的客户。对于更广泛的应用和支持使用行业标准库和框架进行软件定义编程，还存在很大的障碍。reVISION™堆栈的诞生，正式为解决这个通往广泛应用的障碍而来。reVISION™堆栈：消除广泛机器学习应用的障碍众所周知，1984 年在加利福尼亚圣何塞市成立的赛灵思是 FPGA 的发明者。FPGA 全称为现场可编辑门阵列，作为专用集成电路领域中的一种半制定电路，可以针对特定任务进行重新编辑，计算效率高。作为近些年备受业界关注的深度学习计算硬件平台，FPGA 市场一直被各巨头公司所关注、看好。2015 年英特尔完成了其迄今为止最大收购——以 167 亿美元收购赛灵思的竞争对手 FPGA 生产商 Altera 就是一个很好的证明。事实上，赛灵思公司早在 2016 年就实现了从 FPGA（可编程逻辑）向 All Programmable(全可编程) 产品和技术的全面转型，现今产品覆盖 FPGA、SoC、MPSoC、RFSoC、3DIC。这次转型首先从产品上打开了可编程产品在更多领域应用的可能性，其次就是通过工具革新打破硬件编程的模式局限，致力于让广泛领域的工程师们可以使用这种硬件解决方案进行设计——既然是 SoC，是数据中心，那么面向的必然是广大的软件、算法工程师们。因此，赛灵思在工具上有了主要针对软件及算法工程师而且使用户增长 5 倍达 25 万的蓝图，即赛灵思工具上的三大步：2012 年推出 Vivado HLS (高层次综合) 工具，可以将 C,C++ 或者 System C 代码自动转化为硬件面试语言。Vivado HLS 不仅能加速算法实现，还能将验证时间缩短多达 1 万倍。然而这个工具还是需要硬件专业人员的参与。为进一步加快设计进程，减少对硬件专家的依赖，赛灵思在 2015 年推出了基于 C、C++和 OpenCL 语言的 SDSoC 开发环境。虽然这帮助其它上千名能够开发自己的基础平台、库和应用的用户大幅缩短了开发周期，但仍无法满足广泛机器学习应用推广与部署的要求，而且机器学习也带来了复杂问题。如今，在这样的大环境下，赛灵思推出了 reVISION™堆栈技术，致力于实现传统的嵌入式视觉系统到视觉导向的自动化系统的转变，并移除全可编程技术广泛应用的障碍。全可编程技术向广泛视觉导向机器学习应用扩展的障碍在于软件定义的编程模式、库以及框架。而在软件定义开发方面，易用性恰恰是用户关注的重点。「reVISION™堆栈的诞生正是为此而来」，Steve Glaser 说道。reVISION™堆栈的诞生扫清了全可编程技术广泛应用的障碍，支持具有很少甚至没有硬件知识或 RTL 设计专长的软件和系统工程师，使其可以使用软件定义开发流程就能将机器学习和计算机算法的高效实现方案整合到响应迅速的系统中，更轻松、更快速地开发视觉导向的智能系统。一旦将机器学习、计算机视觉、传感器融合和连接的优势融为一体，这些工程师将从中大受裨益。reVISION™堆栈包括用于平台、算法和应用开发的丰富开发资源。它支持最流行的神经网络，例如 AlexNet、GoogLeNet、SqueezeNet、SSD 和 FCN，同时也支持库元素如卷积神经网络网络层的预定义优化型实现方案，这也是构建定制神经网络所需的。同时，堆栈配合了丰富的满足加速要求的 OpenCV 功能，可以支持机器视觉处理。对应用层面的开发来说，赛灵思支持流行的框架，包括用于机器学习的 Caffe 和用于计算机视觉的 OpenVX（将于 2017 年下半年推出）。reVISION™堆栈还包括赛灵思和第三方提供的基于 Zynq SoC 和 MPSoC 的开发平台。Steve Glaser 称，虽然目前仅支持 Caffe 框架，但是未来计划拓展到更多的框架比如 TensorFlow，也会根据用户的需求进行拓展。reVISION™堆栈包含广泛的平台、算法、应用开发资源同时，reVISION™堆栈开发流程从熟悉的 C、C++、OpenCL 语言及相关编译器技术的基于 eclipse 的开发环境（即 SDSoC 开发环境）启动。在 SDSoC 环境中，软件工程师和系统工程师能以 reVISION 硬件平台为目标，并采用大量的加速就绪型计算机视觉库，很快还能采用 OpenVX 框架，允许开发者快速构建应用。reVISION™堆栈软件定义流程针对机器学习算法，可以利用 Caffe 等流行的框架来培训神经网络，用 Caffe 生成的.prototxt 文件对基于 ARM 的软件调度器进行配置，从而驱动专门为可编程逻辑预先优化的 CNN 推断加速器。对计算机视觉和其他专有算法来说，用户可对软件代码进行特征分析，发现瓶颈，并在代码中标出希望加速并进行「硬件优化」的特定功能。「系统优化编译器」则用来创建加速的实现方案，包括处理器/加速器接口（数据移动器）和软件驱动器。结合计算机视觉和机器学习功能，该编译器能创建优化的融合实现方案。reVISION™堆栈易用性赛灵思嵌入式视觉及 SDSoC 高级市场经理 Nick Ni 表示：「我们的目的就是让更多软件工程师和系统工程师无需掌握或只需掌握一点硬件设计专业技术，就能够更轻松快速地开发出智能嵌入式视觉系统，包括将机器学习和计算机视觉算法的超高效实现方案整合到高响应性系统中。以 OpenCV 为例，OpenCV 库函数对于开发许多计算机视觉应用来说是比较重要的。目前我们可以提供部分已经进行优化好的库，不需要开发者自己来写硬件代码，可以直接用我们的工具库进行生成。利用 reVISION™进行计算视觉的设计流程是：在 Zynq 平台上交叉编译 OpenCV application，列提纲并确定瓶颈函数，最小化代码变动并将函数烧入硬件中，将生成的 SW/HW 图片复制到 SDCard 并在 Zynq 开发板上运行。五月份，我们将会发表约 50 个优化好的库，未来会结合用户的需求对库进行更全面的优化，致力于为客户提供 80% 的解决方案，而剩余的 20% 则是用户的 100%，是用户将独特创意实现的过程。」reVISION™堆栈叫板 CPU/GPU除了 FPGA，时下主流的人工智能算法，深度学习计算硬件平台还包括 CPU、GPU、ASIC。CPU 作为最初用作硬件平台的通用处理器，通用性好，模块功能多，逻辑处理能力强，可以完成复杂度高的计算，但是在执行深度学习算法时计算性能一般。GPU 不同于 CPU 的单线程处理，结构简单，提供了大量的计算单元，更能适应深度学习大量的矩阵、卷积运算，英伟达公司就一直在 GPU 领域占主导地位。ASIC 作为一种为专门目的而设计的集成电路，是面向特定用户的需求的，具有不产生冗余、计算性能高、功耗低的特点，比如 Google 的 TPU。Steve Glaser 为我们展示了带有 reVISION™的典型 SoC 与传统 CPU 和 GPU 以及典型 SoC 的比较结果。从图中可以看出，reVISION™不但能支持从推断到机器学习推断和互联控制的优化，系统响应时间最快，还能为硬件优化的算法加速提供所需的可重配置性，并具备能升级更新到最新传感器和连接性的需求。从响应时间和可重配置性方面，对带有 reVISION™的典型 SoC 与传统 CPU 和 GPU 以及典型 SoC 进行性能比较仅针对响应时间而言，CPU 和传统 GPU 针对的是机器学习的训练过程，而赛灵思则着手于从传感器到推断和控制的最低时延来实现最快响应性。嵌入式 GPU 和典型 SoC 需要从传感器到视觉、机器学习和控制处理频繁访问外部存储器。相比之下，赛灵思基于 Zynq SoC 的 reVISION™部署了使用可编程逻辑和较多的内部存储器实现的优化和流线型数据流。在与英伟达先进处理器 NVIDIA Tegra X1 进行基准对比时，基于 reVISION™的流程在机器学习方面单位功耗图像捕获速度提升 6 倍，在计算机视觉处理的帧速率提升 40 倍，时延仅为 1/5（以毫秒为单位），这些确定性的响应能力指标正是对于实时应用十分重要的。用于推断和控制的最低时延传感器作为一切技术创新、落地的基础，半导体芯片产业持续升温，各公司对于半导体芯片领域的研发是一场没有硝烟的战场。近年来，各巨头公司为扩大、占领半导体芯片市场战略举动层出不穷，竞争也愈发激烈。赛灵思 reVISION™堆栈的发布，无疑将让机器学习开发平台市场的竞争进一步加剧，然而对于创意不断的用户市场，有一个强大新平台可以选择，无疑是一个振奋人心好消息。  

韩松在FPGA'17会场讲解 ESE 硬件架构FPGA 领域顶级会议 FPGA 2017 于 2 月 24 日在加州 Monterey 结束。在本次大会上，深鉴科技论文《ESE: Efficient Speech Recognition Engine with Sparse LSTM on FPGA》获得了大会最佳论文奖（Best Paper Award）。图1:韩松提出的深度学习部署方案。跟传统的「训完即用」的方案相比，「训练后经过压缩再用硬件加速推理」的方案，可以使得推理更快、能耗更低。该项工作聚焦于使用 LSTM 进行语音识别的场景，结合深度压缩（Deep Compression）、专用编译器以及 ESE 专用处理器架构，在中端的 FPGA 上即可取得比 Pascal Titan X GPU 高 3 倍的性能，并将功耗降低 3.5 倍。而此前，本文还曾获得 2016 年 NIPS Workshop on Efficient Method for Deep Neural Network 的最佳论文提名。据悉，本文所描述的 ESE 语音识别引擎，也是深鉴科技 RNN 处理器产品的原型。图 2：ESE 语音识别引擎工作全流程LSTM 全称为 Long-Short Term Memory，在语音识别、机器翻译、Image Captioning中有较多的应用。对于语音识别而言，LSTM 是其中最重要一环，也是计算耗时最多的一环，通常占到整个语音识别流程时间的 90% 以上。图 3：LSTM 在语音识别中的位置Deep Compression 算法可以将 LSTM 压缩 20 倍以上。但在以往的纯算法压缩上，并没有考虑多核并行时的负载均衡，这样在实际运行时，实际的运行性能被负载最大的核所限制。本文提出了一种新的 Load Balance Aware Pruning，在稀疏化时保证剪枝后分配到每个核的计算量类似，从而进一步加速的计算。图 4：Load-Balance-Aware Pruning示意：保证稀疏性的同时保证多核负载均衡结合新的模型压缩算法以及 ESE 专用处理架构，在一个可实际使用的 LSTM 模型上测试，相同情况下，深鉴基于中等 FPGA 平台的耗时为 82.7us，功耗为 41W；而 Pascal Titan X GPU 则需要 287.4us 的运行时间，并且耗能 135W。这也再次证明了稀疏化路线的作用：在价格、资源全面弱于 GPU 的专用硬件上，通过算法与硬件的协同优化，的确可以取得更好的深度学习运算能力。深鉴科技成立于 2016 年 3 月，创始成员来自清华大学和斯坦福大学，公司致力于结合深度压缩与深度学习专用处理架构，提供更高效与便捷的深度学习平台。公司聚焦于稀疏化神经网络处理得技术路线，提出的 Deep Compression 算法可以将模型尺寸压缩数十倍大小而不损失预测精度，并结合专用的深度学习处理架构来实现加速。而 ICLR 2016 和 FPGA 2017 两篇最佳论文的获奖，也证实深鉴科技所聚焦的稀疏化路线越来越得到深度学习界的关注。论文：ESE: Efficient Speech Recognition Engine with Sparse LSTM on FPGA摘要：长短期记忆网络（LSTM）被广泛用于语音识别领域。为实现更高的预测精度，机器学习研究者们构建了越来越大的模型。然而这样的模型十分耗费计算和存储资源。部署此类笨重的模型会带数据中心来很高的功耗，从而带来很高的总拥有成本（TCO）。为了增加预测速度，提高能源效率，我们首次提出了一种可以在几乎没有预测精度损失的情况下将 LSTM 模型的尺寸压缩 20 倍（10 倍来自剪枝和 2 倍来自量化）的负载平衡感知剪枝（load-balance-aware pruning）方法。这种剪枝后的模型对并行计算很友好。另外，我们提出了可以对压缩模型进行编码和分割成 PE 以进行并行化的调度器（scheduler），并编排了其复杂的 LSTM 数据流。最后，我们设计了一种可以直接在这种压缩模型上工作的硬件框架——Efficient Speech Recognition Engine (ESE)。该框架使用了运行频率为 200 MHz 的 Xilinx XCKU060 FPGA，具有以 282 GOPS 的速度直接运行压缩 LSTM 网络的性能，相当于在未压缩 LSTM 网络上 2.52 TOPS 的速度；此外，该框架执行一个用于语音识别任务的全 LSTM 仅需 41 W 功耗。在基于 LSTM 的语音基准测试中，ESE 的速度为英特尔 Core i7 5930k CPU 的 43 倍，英伟达 Pascal Titan X GPU 的 3 倍。它的能量效率分别为以上两种处理器的 40 倍和 11.5 倍。

新春过后不久（2 月 4 日- 9 日），我们就迎来了 2017 年人工智能领域的首个重磅会议——AAAI-17，这也是第 31 届 AAAI 人工智能大会。机器之心在这场会议前后对该会议的亮点进行了跟踪报道和深度解读，详情参阅机器之心的相关报道《人工智能顶级会议 AAAI-17 亮点前瞻：洞见人工智能最前沿》、《提升人工智能准确度, 微软解读多项 AAAI-17 研究》、《MIT AAAI-17 研究展示:为规划算法加入人类直觉》、《AAAI-17 获奖论文深度解读（上）：从无标签监督学习到人工智能道德框架》和《AAAI-17 获奖论文深度解读（下）：蒙特卡罗定位和推荐系统》。而在本届 AAAI 大会上，华人力量的崛起也是一个非常值得关注的看点。在接收论文的列表上，我们也能很明显地看到大量华人研究者的名字，当然，其中有很多论文实际上是中外研究机构合作的成果，比如由加州大学伯克利分校和今日头条实验室合作发表的论文《一个用于时间模型中联合参数和状态估计的近似黑箱的在线算法（A Nearly-Black-Box Online Algorithm for Joint Parameter and State Estimation in Temporal Models）》。这篇论文的作者有来自伯克利电气工程与计算机科学系的 Yusuf B. Erol、吴翼（Yi Wu）和 Stuart Russell，以及来自今日头条实验室的李磊（Lei Li）。论文摘要：对于时间模型而言，在线的联合参数和状态估计是一个核心问题。现有的绝大多数方法不是受限于特定类别的模型（比如 Storvik 过滤器），就是计算成本过高（例如，particle MCMC）。我们提出了一种全新的近似黑箱算法（nearly-black-box algorithm）——预设参数滤波算法（Assumed Parameter Filter/APF），这是一种用于状态变量的粒子滤波（particle filtering）和用于参数变量的预设密度滤波（assumed density filtering）的混合。它具有以下优势：（a）它是在线的并且在计算上是高效的；（b）适用于带有任意转变动态（transition dynamics）的离散和连续参数空间。和一些标准算法相比，在计算负载固定时，APF 在几种不同的模型上都生成了更加准确的结果。大会结束之后，机器之心对 Yusuf B. Erol、吴翼和李磊进行了专访，请他们解读了这份研究成果并谈了谈对其它一些问题的看法。在此之前，先让我们对本文的这三位主角作一个简单介绍。Yusuf Bugra Erol 和吴翼都是著名计算机科学学者 Stuart Russell 教授的博士学生，其中吴翼参与过的论文《Value Iteration Networks》在去年 12 月的 NIPS 2016 上获最佳论文奖（参看报道《机器之心对话 NIPS 2016 最佳论文作者：如何打造新型强化学习观？》）。而现任今日头条科学家、头条实验室总监的李磊也曾在伯克利进行过博士后研究（参看机器之心的专访《头条实验室科学家李磊：准确率更高的问答系统和概率程序语言》）。以下是机器之心对该论文的这三位作者的采访内容：论文解读机器之心：首先请为我们简单介绍一下这篇论文的研究成果。李磊：人工智能研究的恒久主题之一是对通用表示框架和快速推理算法的探索。时序概率模型中（即随时间变化的模型），参数和隐变量的在线联合估计通常比较困难。本文针对非常广泛的概率时序模型，提出一个通用且高效的参数和隐变量估计算法，称作预设参数滤波算法（Assumed Parameter Filter/APF）。这个算法将可用来解决几乎任意的时间序列模型中推理问题，且是在线估计，所以可以解决很长或者持续时间序列的问题。机器之心：您提出的算法有什么看点？Yusuf Erol：我们的算法有以下特色：1. 通用，适用于（几乎）任意时间序列模型（状态空间模型）；2. 适用于持续时间序列数据；3. 可以处理未知状态和参数的联合估计，之前的算法很多都只能估计未知状态，而能估计未知参数的算法都是离线的，比较慢；4. 理论上可以逼近真实解。机器之心：可以举例说明一下吗？Yusuf Erol：举个例子，医院急症看护病房每个病人都接了很多监测仪器，持续测量血压、心跳、呼吸等生理指标。很多指标的采样频率很高，数据量非常大，靠护士监管看不过来，需要通过算法从这些持续监测的生理指标时间序列数据中实时自动的分析出病人状态，以便预测并应对突发情况，比如突发休克。这个问题一个方法是通过建立多维时间序列模型，这些模型刻画了人身体内生理运转状况，其中有些变量是没有直接监测到的（通常称作状态（state）），比如血管内流量大小和速度，还有一些是因人而异的参数比如脑容量大小、身高和体重等。需要解决的问题是有了时间序列模型和观测数据（比如血压和心跳）后，如何实时快速的估计出未知的变量和参数。为了方便的实验验证各种模型，需要一个通用的表示框架，以及一个通用黑盒的推理方法。我们采用概率编程语言 BLOG 作为表述模型的框架，这个框架可以描述非常广泛的模型，我们论文解决的就是在通用框架里面有了观测数据、有了模型时，如何快速且自动地做推理。机器之心：这个算法能够怎样帮助用户？李磊：概率程序可以给一线工程师和应用方提供简单快速验证各种设想的方案，使用方只要熟悉他需要解决的问题学会这个建模语言，即使不了解机器学习如何做推理，也可以通过概率程序的自动推理引擎来做解决方案，极大地降低了机器学习使用门槛。通过概率程序来表达时间序列模型也有同样的便利。机器之心：APF 和以往的 SSM 比有那些优势？Yusuf Erol：传统 SSM 推理算法（Particle filter, PMCMC 等）要么只能估计动态隐变量，不能估计静态参数（SMC algorithms)；要么只适用特定模型（Extended Parameter Filter）; 要么虽然通用但速度很慢，是离线算法（PMCMC)。我们的算法在上述三方面都有优势。机器之心：SSM 的适合的应用有哪些？Yusuf Erol：SSM 适合应用于需要对时间变化建模的数据。机器之心：您认为输入的预设参数会对结果造成什么影响？Yusuf Erol：我们算法的误差一方面来自于用于逼近的统计量是有限维度的。只要模型本身的真实后验概率可以计算，我们算法就可以工作得很好。尤其是如果参数的真实后验分布是高斯分布，那么就可以在理论上证明算法收敛。应用中发现实际效果比理论更好。机器之心：可以使用一个生成器来自动生成不同的预设密度吗？可以变成完全的黑箱算法吗？吴翼：这是一个很有趣的问题，要让算法真正完全黑箱（black-box），需要对任意近似分布（approximate distribution）都能进行统计量（sufficient statistics）的更新计算。对于任意指数类（exponential family）的分布，可以利用变分推理（variational inference）技术进行后验概率计算。当然，自然而然的问题是：我们能不能用一个程序来帮助人自动做数学计算呢？从这个大的角度看，这是一个很难的问题，也是很有趣的问题。学术界有非常多的尝试，比如大家熟知的 Mathematica 软件就是一个成功的产品，现在大家也尝试用深度学习的方法让 AI 自动进行数学定理的证明。希望在不久的将来，AI 可以完成开放性问题的数学证明。机器之心：今日头条在这方面有哪些计划和打算，会把这项研究应用到产品中吗？李磊：有好几个可能应用，今日头条的主产品是个性化内容推荐，把推荐做好，需要对文章图片视频进行分析，理解文章里面有哪些人物和事件，多个文章里面的同一事件是如何演化的，这里需要时序模型；今日头条的产品运营中有很多记录的时间序列数据，比如每个时刻各个地区的访问量、阅读停留时间，时间序列模型也可以对这些数据建模；我们的数据中心检测同样有很多数据，比如每分每秒每个服务器的负载、流量、温度等，通过时间序列对其建模可以做预测，进行灾害预警。关于概率编程机器之心：听说您们负责了一个 DARPA 项目的子项目 PPAML，能简单介绍一下吗？吴翼：PPAML 的全名是 Probabilistic Programming for Advanced Machine Learning。是由 DARPA（Defense Advanced Research Projects Agency）推动的一项历时 4 年的基础科学研究。DARPA 中文名是国防高等研究计划署，隶属于美国国防部，致力于各种前瞻性研究，历史上一直都是各种黑科技的孵化器和诞生器。从基础的科学研究到美国绝密的武器装备的研究，DARPA 都有涉及。比如互联网的雏形就诞生于 DARPA，现在普及大众的人脸识别技术也是 DARPA 最先推动的，美国的很多自动驾驶、机器人、无人机技术也是 DARPA 推动的。PPAML 项目作为一项基础科学研究（当然不是绝密的军工项目了，不然我作为中国人也不可能参与其中），旨在推动概率编程语言的进步和发展，来让各个科学领域享受到计算机科学和机器学习科学的红利，提高各个科学领域的数据分析效率以推动整个科学界的更快发展。机器之心：请您简要介绍一下概率编程（PP）和深度学习的区别，以及各自的优势和劣势。李磊：概率编程是通过程序语言来定义概率模型，由通用的概率推理系统来自动求解。深度学习的模型也可以通过程序来定义和求解，这一点上两者是相似的。最大的区别在表达能力和推理算法，深度学习的模型是可导（或次可导）函数构成的，概率程序表达能力通常更强，神经网络模型可以表达成为概率程序的一个特殊子类别。由于深度学习的模型具有很强的特殊性，因此深度学习系统可以相对容易地采用梯度下降算法来求解。而概率程序的通用算法通常基于马尔可夫链蒙特卡罗法（MCMC）。广义而言，概率编程语言考虑的模型是任意可以用程序表达的结构：而我们知道程序中有分支（if）、循环（for loop）、递归（recursion），一个图灵完备（Turing complete）的编程语言需要能够表达任意可在图灵机上执行的程序。由于概率编程语言具有极强的表达性，这给自动推断系统带来了很大的难度——当然，因为通用，最大的局限是推理速度缓慢。我们的工作就是在保持概率编程表达性的前提下提高推理速度。也正是由于概率编程强大的表达能力，可以让概率编程惠及更多的受众，比如其他领域的科学家、认知科学家、数据科学家等等。使用者不需要对机器学习的推理算法有深入了解，只需要掌握建模语言，即可方便快速地构建和应用机器学习模型。机器之心：您认为用编译的方法来优化机器学习的意义大吗？吴翼：由于概率编程语言强大的模型表示能力，其背后的通用推理系统往往效率低下。系统的效率低下往往有着两个方面的原因：1. 推断算法收敛速度慢； 2. 算法执行和系统实现效率低下。要提高概率编程语言的推断效率，显然我们需要双管齐下。概率编程语言和普通的编程语言（比如 Python、C、Java）的编译有着本质的不同。对于普通编程语言（例如 C 语言），编译器并不会更改程序员写的代码语义，只是在代码上做同语义的改写。比如程序员写了 print("hello world!")，那么正确的编译器不论怎么改写，用户执行编译后的可执行代码，执行的结果都是在屏幕上显示「hello world」。然而对于概率编程语言却并不是这样：程序员只是用编程语言描述了模型是什么，至于怎么根据这个模型计算、算法怎么实现，都是编译器需要操心的事情。一般来说概率编程语言所采用的系统设计，往往是读入用户输入的模型，并存储成某种数据结构，然后选用开发人员预先写好的某个算法，在这个数据结构上进行计算。这样的执行方式是解释性的（interpretive，比如 Python 就是解释性的语言），有很多的冗余。而一个好的概率编程语言编译器，需要对于用户输入的不同模型结合选用的算法做深度的分析和优化，并自动生成专门对于当前模型定制的算法实现。比如我们的 Swift 编译器，就可以在采用相同算法的前提下，将概率编程语言的推断速度提高 100 倍以上。机器之心：这个研究在哪些方向上还能继续拓展？Yusuf Erol：非常高维的状态空间模型中的推理算法，理论上更强的结果等。吴翼：引入更多程序语言编译优化的算法来加速推理。比如部分计算。我们也在一直完善和加强 compiler，增加特性，提高性能，增加可用性等等。我们也在考加更多的算法让整个概率编程语言系统有更多的算法可用。其它问题机器之心：您如何评价这届 AAAI 会议中的华人力量（华人的论文数量和质量以及代表性论文）？李磊：现在人工智能领域的研究者越来越多，也越来越多样化，他们研究着更多样的问题，产出着更多更好的成果，这是很好的趋势。但作为科研工作者，我们更关注研究本身，但不关注这个研究是什么种族的人做的。当然，我们也尽一切努力推动中国的人工智能研究，这也是为科学进步做贡献。机器之心：科学理念上的信仰对您搞研究重要吗？对不同理念的研究应该持什么态度？李磊：之前做时间序列用贝叶斯模型多，最近几年做自然语言的问题用神经网络模型多。派别之争对我来说意义不大，但我喜欢贝叶斯模型的清晰结构和可解释性，也喜欢神经网络在大量标注数据下的效果，Frequentist 方法用得少却不排斥。科学研究讲求方法论，多样化才有可持续性。机器之心：在您看来人工智能现阶段是更受限于算法还是运算力？李磊：人工智能模型、推理算法、计算速度一直是紧密关联，螺旋上升的。目前三者都各自有挑战。机器之心：今日头条在人工智能上主要有哪些方向的研究？李磊：围绕自然语言理解和图像视觉做了一些研究，自然语言理解方面，比如新闻生成、自动摘要、文本分类、自动问答、评论分析；图像视觉方面，比如视频内容理解、分类、相似和重复内容识别、物体检测追踪等。机器之心：您还希望通过人工智能帮助哪些其它方向上的发展？李磊：比如医疗监控、辅助诊断、心理建模分析、环境变量建模分析等。

随着大数据、云计算、人工智能等技术应用的普及，数字化转型浪潮以磅礴气势席卷全球。如今，对于企业来说，“数字化转型已经不是选择题，而是必选题。”与此同时，变革开始逐步由应用层深入到基础架构层——数字化转型进入深水区。作为三大核心基础软件领域之一的数据库行业也在经历这样的变革。其推力不仅来自于技术本身的迭代进化，更源于产业快速发展带来的新需求与新挑战。而 OceanBase 原生分布式数据库凭借“十年磨一剑”的技术积累，正在成为企业核心系统首选，推动企业数字化转型，助力业务发展。业务有需求 但技术改不了技术改不了、服务挺不住、管理环节多、业务跑不动是很多企业在进行数字化转型过程中最常面临的挑战。治标易，治本难，其“病灶”在于：核心系统是对于数据库的全面下探，而当业务快速增长产生海量数据时，传统以 Oracle 集中式数据库为底层架构的核心系统在数据收集、分析、处理，及上层应用的支持方面变得力有不逮。以国内某头部保险企业A为例，其核心系统面临的挑战是“技术改不了”的问题。A公司业务体量庞大，横跨寿险、财险、银行、基金、资产管理、财富管理等多个领域；业务系统包括核心交易系统、多元销售、个险销售、经营管理、精算系统更等；涉及到理赔、契约、核保、再保、保单管理、团险、网销等全链路业务与服务。本次升级针对寿险业务，其系统整体达300多套，且大部分是多年前基于 Pro*C 和 Tuxedo 开发，代码达1400多万行，数据量400多TB，量级巨大。如果做类似分库分表，那么从 Oracle 到 MySQL 的适配风险非常高。因此A公司虽然有意愿，但内外部一直没有合适团队可以解决这个难题。高兼容、多租户能力保证核心系统平滑升级面对如此量级的数据和复杂的升级挑战，OceanBase 项目团队根据其特点，认为寿险系统数据库平迁方式更符合实际。这样可以保证大量应用不做大改动或重构，避免“数据库+应用”双重风险的叠加。得益于 OceanBase 对 Oracle 等传统数据库的高兼容能力，不仅兼容 SQL 语言，还包括完整的 PL/SQL 能力，能提供完全兼容的语法和接口调用。原应用只需极少适配就能在 OceanBase 上正常运行，节省了大量时间和成本。不仅如此， OceanBase 根据A公司的实际情况快速迭代产品，提供了适配 Pro*C+Tuxedo 的无缝迁移解决方案，自主研发的嵌入式SQL预编译器（ECOB）支持替换旧的 Pro*C 预编译器，能将A公司的老核心系统顺利迁移到 OceanBase 上来，避免了上千万行代码重写的麻烦。除了高兼容性保证平滑适配以外，OMS 迁移平台的强大支持和灵活的迁移方案能力也很重要，为大量系统实现平滑升级提供保障。通过精算架构的灵活改造，基于物理备份的表粒度恢复能力，能全面有效取代原有基于存储 BCV技术的数据复制方案，极大的节省了硬件资源成本，加快了数据再生，更加灵活易操作。通过多租户能力，业务团队将A公司寿险业务的300多套系统并入到10多套的 OceanBase 集群，帮助A公司实现每个业务一个租户，保证资源逻辑隔离，同时在线扩容/缩容无需数据重分布。这不仅大大降低了数据管理难度，还能通过原生分布式数据库特有的在线扩容、在线收缩能力支撑A公司“开门红”等业务高峰场景，这在从前是无法实现的。 稳定可靠 创造新价值经过一年多的实战，OceanBase 数据库运行稳定，为A公司创造了新的价值：自主研发：OceanBase 产品100%自主研发，有效支持企业技术改造的诉求，同时保证数据安全，较好地防范化解“卡脖子”风险。降低开发运维成本：多租户集群化部署在提供更好的性能表现以及业务连续性保障的同时，大大缩减了硬件成本。如一期的数十个系统在 Oracle 上使用空间约30TB，到 OceanBase 后不到4TB，压缩比高达近8倍。其次，实现了集中管控，将以前数百套 Oracle 数据库纳入到数个集群，节省了硬件成本和运维管理成本，每年整体节省成本（软硬件、服务、开发）数千万元。同时，Oracle/MySQL 的语法兼容性极大的减少了开发人员对于应用业务适配改写的成本，保护了A公司的既有投资。在线弹性扩容/缩容：最大化资源利用，通过动态弹性调整租户计算资源，敏捷的应对业务负载要求的变化，顺利通过季度、年度开门红等业务冲刺高峰。保障业务稳定运行：有效利用数据多副本的架构能力，在充分利用所有节点的计算能力的同时，提供数据和节点的高可用性，RPO=0，RTO<30s，降低系统性风险。A公司是 OceanBase 在保险行业的成功实践案例之一，目前 OceanBase 已助力200+行业客户实现核心系统升级，帮助客户更高效、更低成本地推进数字化转型，在数字化浪潮中快人一步。

随着 AlexNet 的划时代论文横空出世，GPU 就开始在服务器端的机器学习加速领域称霸。然而，随着研究的深入，人们发现了比 GPU 架构更灵活的 FPGA 在机器学习加速领域也有自己的优势，并有多家公司和学校发表了相关研究结果。那么，现在服务器端人工智能应用 GPU 和 FPGA 到底哪个强？本文将作深入分析。为什么 GPU 和 FPGA 能加速机器学习算法？ GPU（上图）与 FPGA（下图）在很久很久（其实也没多久，大概五年前），人们在跑机器学习算法时用的主要还是 CPU，因为 CPU 通用性好，硬件框架已经很成熟，对于程序员来说非常友好。然而，当机器学习算法的运算量越来越大时，人们发现 CPU 执行机器学习的效率并不高。CPU 为了满足通用性，芯片面积有很大一部分都用于复杂的控制流，留给运算单元的面积并不多。而且，机器学习算法中运算量最大的矩阵运算是一种矢量（Vector）运算，而 CPU 对于矢量运算只能说是部分支持。这时候，GPU 进入了机器学习研究者的视野。GPU 原本的目的是图像渲染，因此使用完美支持矢量运算的 SIMD（单指令流多数据流，single instruction multiple data）架构，而这个架构正好能用在机器学习算法上。GPU 本来就是为了加速 3D 游戏性能的加速器，这里又被用到了加速机器学习应用上，其实是很有趣的一件事。GPU 运行机器学习算法比 CPU 快很多，但是毕竟不是为机器学习而设计的。有人就要问，如果做一块完全为机器学习设计的运算单元，会不会比 GPU 更有效率？不过，要真的做一块机器学习专用芯片（ASIC）需要极大的决心，首先为了性能必须使用最好的半导体制造工艺，而现在用最新的工艺制造芯片一次性成本就要几百万美元，非常贵。就算你有钱，你还需要拉一支队伍从头开始设计，设计时间往往要到一年以上，time to market 时间太长，风险很大，所以除了 Google 之外很少有人敢做 ASIC。这时候，FPGA 就吸引了大家的注意力。FPGA 全称「可编辑门阵列」(Field Programmable Gate Array)，其基本原理是在 FPGA 芯片内集成大量的数字电路基本门电路以及存储器，而用户可以通过烧入 FPGA 配置文件来来定义这些门电路以及存储器之间的连线。这种烧入不是一次性的，即用户今天可以把 FPGA 配置成一个微控制器 MCU，明天可以编辑配置文件把同一个 FPGA 配置成一个音频编解码器。所以说在 FPGA 可以快速实现为机器学习算法开发的处理器架构，而且成本很低（一块 FPGA 开发板大约售价 1000 美金，比真的制造芯片便宜太多）。ASIC 是一锤子买卖，设计出来要是发现哪里不对基本就没机会改了，但是 FPGA 可以通过重新配置来不停地试错知道获得最佳方案，所以用 FPGA 开发的风险也远远小于 ASIC。GPU 与 FPGA 的性能分析对比那么在服务器端 GPU 和 FPGA 谁更强呢？在服务器端，有几个指标可供对比：峰值性能灵活性平均性能功耗和能效比其实这几个指标是会互相影响的，不过还是分开说。从峰值性能来说，GPU（10Tflops) 远远高于 FPGA(<1TFlops)。GPU 上面成千上万个 core 同时跑在 GHz 的频率上还是非常壮观的，最新的 GPU 峰值性能可达 10TFlops 以上。GPU 的架构经过仔细设计（例如使用深度流水线，retiming 等技巧），在电路实现上是基于标准单元库而在关键路径（即芯片中一个时钟周期内延迟最长的路径，直接决定了电路最高运行速度）上可以用手工定制电路，甚至在必要的情形下可以让半导体 fab 依据设计需求微调工艺制程，因此可以让许多 core 同时跑在非常高的频率。相对而言，FPGA 首先设计资源受到很大的限制，例如 GPU 如果想多加几个 core 只要增加芯片面积就行，但 FPGA 一旦你型号选定了逻辑资源上限就确定了（浮点运算在 FPGA 里会占用很多资源），好汉也会被尿憋死。而且，FPGA 里面的逻辑单元是基于 SRAM-查找表，其性能会比 GPU 里面的标准逻辑单元差好多。最后，FPGA 的布线资源也受限制（有些线必须要绕很远），不像 GPU 这样走 ASIC flow 可以随意布线，这也会限制性能。 FPGA 布线资源有限，有些线必须走非常长，从而限制了时钟频率除了芯片性能外，GPU 相对于 FPGA 还有一个优势就是内存接口。GPU 的内存接口（传统的 GDDR5，最近更是用上了 HBM 和 HBM2）的带宽远好于 FPGA 的传统 DDR 接口（大约带宽高 4-5 倍），而众所周知服务器端机器学习算法需要频繁访问内存，因此内存接口的带宽可以决定机器学习应用的性能。  传统显卡用的 GDDR 标准带宽比 FPGA 使用的 DDR4 大 4-5 倍（上图），而高端显卡更是用上了带宽更大的 HBM 接口的（中图），而即使高端 FPGA（如 Xilinx Ultrascale）的内存接口仍然是普通的 DDR4（下图）但是从灵活性来说，FPGA 远好于 GPU。FPGA 可以根据特定的应用去编程硬件（例如如果应用里面的加法运算非常多就可以把大量的逻辑资源去实现加法器），但是 GPU 一旦设计完那就没法改动了，没法根据应用去调整硬件资源。目前机器学习大多数适合使用 SIMD 架构（即只需一条指令可以平行处理大量数据），因此用 GPU 很适合。但是有些应用是 MISD（即单一数据需要用许多条指令平行处理，微软在 2014 年 ISCA paper 里面就举了一个 MISD 用于并行提取 feature 的例子），这种情况下用 FPGA 做一个 MISD 的架构就会比 GPU 有优势。不过 FPGA 的编程对于程序员来说并不容易，所以为了能让机器学习程序员能方便地使用 FPGA 往往还需要在 FPGA 公司提供的编译器基础上进行二次开发，这些都是只有大公司才能做。 微软在 2014 年 ISCA paper 里面就 MISD 用于并行提取 feature 的例子从上面两条我们可以看出，FPGA 实现的机器学习加速器在架构上可以根据特定应用优化所以比 GPU 有优势，但是 GPU 的运行速度（>1GHz) 相比 FPGA 有优势 (~200MHz)。所以，对于平均性能，看的就是 FPGA 加速器架构上的优势是否能弥补运行速度上的劣势。如果 FPGA 上的架构优化可以带来相比 GPU 架构两到三个数量级的优势，那么 FPGA 在平均性能上会好于 GPU。例如，百度在 HotChips 上发布的 paper 显示，GPU 的平均性能相比 FPGA 在矩阵运算等标准 batch data SIMD bench 上远好于 FPGA；但是在处理服务器端的少量多次处理请求（即频繁请求但每次请求的数据量和计算量都不大）的场合下，平均性能会比 GPU 更好。 Baidu 的研究显示，对于矩阵运算 bench GPU 远好于 FPGA，但是当处理小计算量大批次的实际计算时 FPGA 性能优于 GPU功耗方面，虽然 GPU 的功耗（200W）远大于 FPGA 的功耗（10W），但是如果要比较功耗应该比较在执行效率相同时需要的功耗。如果 FPGA 的架构优化能做到很好以致于一块 FPGA 的平均性能能接近一块 GPU，那么 FPGA 方案的总功耗远小于 GPU，散热问题可以大大减轻。反之，如果需要二十块 FPGA 才能实现一块 GPU 的平均性能，那么 FPGA 在功耗方面并没有优势。能效比的比较也是类似，能效指的是完成程序执行消耗的能量，而能量消耗等于功耗乘以程序执行的时间。虽然 GPU 的功耗远大于 FPGA 的功耗，但是如果 FPGA 执行相同程序需要的时间比 GPU 长几十倍，那 FPGA 在能效比上就没有优势了；反之如果 FPGA 上实现的硬件架构优化得很适合特定的机器学习应用，执行算法所需的时间仅仅是 GPU 的几倍或甚至于接近 GPU，那么 FPGA 的能效比就会比 GPU 强。结语FPGA 可以开发出为机器学习算法专用的架构，但是 FPGA 本身的峰值性能较 GPU 要差很多。FPGA 和 GPU 哪个跑机器学习算法更强（平均性能更好），完全取决于 FPGA 架构优化能否弥补峰值性能的劣势。©本文由机器之心原创，转载请联系本公众号获得授权。

前言这篇文章并不是针对某个知识点深入剖析，而是聚焦在Lua语言的关键知识点覆盖和关键使用问题列举描述。能够让学习者对Lua整体有个认识（使用一门新的语言不仅仅在用的时候适应它，而是知道怎么善于使用它），同时也可以作为一个工具文档在Lua中遇到具体问题的时候能从这里索引到相应的知识点和Lua的一些原理，得到启发。 1、Lua语言的特点简单的说Lua语言是一个可扩展的嵌入型的脚本语言。它具有以下的特点：嵌入式语言： 它是ANSI C实现，在大多数 ANSI C 编译器中无需更改即可编译，包括 gcc（在 AIX、IRIX、Linux、Solaris、SunOS 和 ULTRIX 上）、Turbo C（在 DOS 上）、Visual C++（在 Windows 3.1/95/NT 上）、Think C (MacOS) 和 CodeWarrior (MacOS)。基本上每种编程语言都有调用 C 函数的方法，因此您可以在所有这些语言中使用 Lua。 这包括 C++、Go、Rust、Python、……解释型语言：Lua脚本会先编译成字节码，然后在Lua虚拟机上解释执行这些字节码。保证了它的可移植性动态类型语言：Lua语言本身没有定义类型，不过语言中的每个值都包含着类型信息简洁轻量，运行速度快：它所有的实现不到6000行 ANSI C代码。只包括一个精简的核心和最基本的库，较新的5.4.3版本解释器编译后283kB(Linux,amd64)。同时Lua通常被称为市场上最快的脚本级 HLL 语言设计原则遵循尽量使用机制来代替规则约定： Lua语言中包含的机制有模块管理、自动垃圾收集、元表和元方法、引用机制等。这些机制下面会详细介绍基于这些特点我们会很愿意将Lua嵌入到我们的应用中，用于拓展应用的能力。1.1、Lua与宿主程序的关系以下图显示了Lua与宿主程序之间的关系：可以嵌入到宿主程序，并为宿主程序提供脚本能力，同时可以帮助拓展宿主程序。另外Lua也提供了一些工具帮助编译Lua文本（luac），执行lua脚本（lua）1.1.1、Lua语言的组成Lua C-api：正如上面所说Lua的所有的能力都是在C层实现的，并通过基础的C-api暴露出来。同时Lua也提供auxlib辅助库，它是基于基础C-api的更高一层的抽象封装。与基础API不同，基础API接口的设计力求经济性和正交性，而auxlib力求对于通用任务的实用性。标准库：Lua语言也包含标准库（io, math, string等），不过语言设计者为了保证Lua尽量的小，这些标准库是独立分开的。如果应用不需要用到这些标准库可以不需要加载，如果需要则可以通过luaopen_io等方法加载具体的库，或者>=5.1版本时通过luaL_openlibs来加载所有标准库。拓展三方库：此外Lua还可以扩展其他三方库，方式有3种：在lua中 require “模块名”。require机制下面会介绍，简单说lua的require加载机制会在package.cpath查找”模块名”的动态库并加载，同时找到luaopen_模块名的函数执行，并把执行结果缓存并返回把C方法添加到Lua标准库列表中，例如把luaopen_模块名 添加到由luaL_openlibs打开的标准库列表中使用Lua C api的luaL_requiref方法将模块添加到package.loaded中，该方法同lua的 require方法Lua内置的机制：Lua内置了很多的机制让开发过程尽量的简单，程序尽量的高效。其中包括：模块加载机制（require）,自动垃圾回收机制，元表和元方法的元机制，错误处理机制（pcall）,引用机制（自动管理table的key）等。下面会详细介绍这些机制。Lua编译器：将Lua脚本编译成字节码Lua虚拟机：Lua虚拟机会维护两个状态——global_state和Lua_state。lua_state：包含两个栈，Callinfo 栈（方法调用栈） 和  TValue 栈（数据栈，关于TValue的介绍）。分别用于缓存函数的调用信息的链表和参数传递。在Lua内部,参数的传递是通过数据栈,同时Lua与C等外部进行交互的时候也是使用的栈。global_state: 负责全局的状态，比如GC相关的，注册表，内存统计等等信息1.1.1.1、lua_state、call_info调用栈、数据栈之间的关系参考链接：链接图1.1callinfo 结构组成一个双向链表，它的结构如下：图1.2其中lua_State的base_ci指向第一层调用，而ci则记录着当前的调用。CallInfo会占用栈的一部分，用来保存函数参数，本地变量，和运算过程的临时变量。如图1中callinfo到lua_stack的部分空间映射。1.1.1.2、global_state全局状态从Lua 源码lstate.h中定义的global_State的结构我们可以了解global_state包含的信息：/* ** 'global state', shared by all threads of this state */ typedef struct global_State {   lua_Alloc frealloc;  /* function to reallocate memory */   void *ud;         /* auxiliary data to 'frealloc' */   l_mem totalbytes;  /* number of bytes currently allocated - GCdebt */   l_mem GCdebt;  /* bytes allocated not yet compensated by the collector */   lu_mem GCmemtrav;  /* memory traversed by the GC */   lu_mem GCestimate;  /* an estimate of the non-garbage memory in use */   stringtable strt;  /* hash table for strings */   TValue l_registry;   unsigned int seed;  /* randomized seed for hashes */   lu_byte currentwhite;   lu_byte gcstate;  /* state of garbage collector */   lu_byte gckind;  /* kind of GC running */   lu_byte gcrunning;  /* true if GC is running */   GCObject *allgc;  /* list of all collectable objects */   GCObject **sweepgc;  /* current position of sweep in list */   GCObject *finobj;  /* list of collectable objects with finalizers */   GCObject *gray;  /* list of gray objects */   GCObject *grayagain;  /* list of objects to be traversed atomically */   GCObject *weak;  /* list of tables with weak values */   GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */   GCObject *allweak;  /* list of all-weak tables */   GCObject *tobefnz;  /* list of userdata to be GC */   GCObject *fixedgc;  /* list of objects not to be collected */   struct lua_State *twups;  /* list of threads with open upvalues */   unsigned int gcfinnum;  /* number of finalizers to call in each GC step */   int gcpause;  /* size of pause between successive GCs */   int gcstepmul;  /* GC 'granularity' */   lua_CFunction panic;  /* to be called in unprotected errors */   struct lua_State *mainthread;   const lua_Number *version;  /* pointer to version number */   TString *memerrmsg;  /* memory-error message */   TString *tmname[TM_N];  /* array with tag-method names */   struct Table *mt[LUA_NUMTAGS];  /* metatables for basic types */   TString *strcache[STRCACHE_N][STRCACHE_M];  /* cache for strings in API */ } global_State;global_state包含以下信息：stringtable：全局字符串表, 字符串池化，使得整个虚拟机中短字符串只有一份实例。gc相关的信息l_registry : 注册表（管理全局数据） ，Registry表可以用debug.getregistry获取。注册表 就是一个全局的table（即整个虚拟机中只有一个注册表），它只能被C代码访问，通常，它用来保存 那些需要在几个模块中共享的数据。比如通过luaL_newmetatable创建的元表就是放在全局的注册表中。mainthread：主lua_State。在一个独立的lua虚拟机里, global_State是一个全局的结构, 而lua_State可以有多个。 lua_newstate会创建出一个lua_State, 绑在 lua_State *mainthread.可以说是主线程、主执行栈。元表相关 ：tmname （tag method name） 预定义了元方法名字数组；mt 存储了基础类型的元表信息。每一个Lua 的基本数据类型都有一个元表。 下图描述了gloable_state里面比较主要的一个部分——注册表。 ENV: 图中Lua脚本的的上值_ENV就是注册表里面的全局表_G，它是通过LUA_RIDX_GLOBALS这个索引从注册表里面索引过来的。Lua脚本中的所有对全局变量的引用都是对_G的引用，不过不是直接操作_G，而是指向_G的另一个参数_ENV。1.1.1.3、_ENV 和 _G如上图所示，Lua脚本中访问全局变量实际上是访问的_ENV 表（table类型）, 脚本中对全局变量访问的代码在编译后会被Lua编译器加上_ENV前缀。那么_ENV究竟是什么呢？在Lua语言里，Lua会把所有的代码段都当作匿名函数来处理，而同时也会把_ENV作为该匿名函数的上值绑定到该匿名函数，所以Lua里面的脚本实际会做如下的转换：普通Lua代码写法：x = 10 local y = 20 z = x + y   print("z:" .. tostring(z))   --output --[[     z:30 ]]经过编译器实际转换后会变成这样：local _ENV = _G local func = function(...)     _ENV.x = 10     local y = 20     _ENV.z = _ENV.x + y          print("z:" .. tostring(_ENV.z)) end   func()     --output --[[     z:30 ]]这里引出另2个概念：上值（upvalues），能支持上值的闭包（closure）。下面会详细提到。 2、Lua语言基础上一章了解了Lua大致的样子和它是一门什么样的语言，以及它如何为宿主应用提供嵌入式脚本能力的。接下面我们从一个新手开发者的角度去开启这一门语言吧。2.1、词法规范作为一个开发者在Lua编码时需要遵循它的词法规范，保证一致的编码风格。这里列举一下：标识符（或名称）：是由任意字母、数字和下划线组成的字符串（注意：不能以数字开头）“下划线+大写字母”（例如_VERSION）组成的标识符通常被Lua语言用作特殊用途Lua语言是大小写敏感的，例如：And和AND是两个不同的标识符2.1.1、注释单行注释：-- 这个是注释内容多行注释：–[[注释内容]]，或 –[[ 注释内容 –]]--[[ this is multiline annotatiaon --]]或者--[[ this is multiline annotatiaon ]]注释代码时建议用这种方式： --[[ 注释内容 --]] ，这样在第一行补一个 ‘-’ 字符就可以取消注释了，会非常方便。例如：---[[ local f = function()     print("method in annotation") end --]] -- 这里可以继续调用函数 f f()2.1.2、变量Lua里面定义的变量默认是全局变量，即直接写变量名即为全局变量。相反局部变量的定义需要加 local 关键字来修饰，例如全局变量g_var，局部变量loc_var：g_var = "this is glocal variable" local loc_var = "this is local variabl" print("g_var:" .. tostring(g_var) .. ", loc_var:" .. tostring(loc_var))   --output --[[     g_var:this is glocal variable, loc_var:this is local variabl ]]2.2、Lua 基本类型了解了Lua的词法规范后我们可以着手开始写Lua代码了。Lua是一门动态类型的语言，主要体现在Lua没有类型定义，不过它的每个值都带有类型信息。我们先了解一下Lua有哪些基本类型，Lua有8种基本类型：nil, number, string ,table, function, boolean, userdata, thread。下面一一介绍一下：2.2.1、nilnil代表空，变量定义出来在第一次赋值之前是空的，目的用于告诉lua它是没有初始化的。注意nil在lua里面只有赋值操作=，和判断操作==，～=才有效，其它操作符都会报错，所以这种类型是无法使用的。我们在处理算数运算符或字符串连接符号使用时需要特别注意这个类型的检查，不然程序会出错。例如我们在处理字符串连接建议如下处理：local a = "aaa" .. tostring(b)2.2.2、number在Lua5.2及之前的版本中，所有的数值都以双精度浮点格式表示。从Lua5.3版本开始，Lua语言为数值格式提供了两种选择：integer ——64位整型和float —— 双精度浮点类型。我们在编译Lua库时也可以将Lua 5.3 编译为精简Lua模式，在该模式中使用32位整型和单精度浮点类型。2.2.3、stringLua 语言中字符串是一串字节组成的序列，Lua的核心不关心这些字节以何种方式编码文本，它使用8个比特位来存储。Lua语言中的字符串可以存储包括空字符在内的所有数值代码，这意味着我们可以在字符串中存储任意的二进制数据。就是说也可以使用编码方法（UTF-8，UTF-16）来存储unicode字符串。2.2.3.1、string常使用的方式举例> 获取长度：Lua中获取字符串的长度有两种方式：#字符串和string.len(字符串)。这里推荐使用 “#” 操作符，因为string.len()实际需要先查找string(table)再找其下的len，然后传参调用，至少需要 4 条 lua vm bytecode；而#直接被翻译为LEN指令，一条指令就可以算出来。以下列举了几种获取字符串长度的方式，源文件是用的utf-8编码：local a = "aaa" local a_len = utf8.len(a)   local b = "你好" local b_len1 = utf8.len(b) local b_len2 = #b local b_len3 = string.len(b)   print("a_len:" .. a_len .. ", b_len1:" .. b_len1 .. ", b_len2:" .. b_len2 .. ", b_len3:" .. b_len3)   -- 输出 -- a_len:3, b_len1:2, b_len2:6, b_len3:6> 字符串连接：另一个用的比较多的是字符串连接操作符—— “ .. ”，这里需要关注2个点：.. 操作符不能操作 nil类型。如前面在介绍nil类型时提到的，nil是告诉系统这个变量没有初始化时的类型，只有在使用判断符号和赋值符号不会出错，其他操作符号都会出错。所以在使用 “..” 连接操作符时务必要检查它不为nil字符串连接操作符在连接多个操作符时实际会创建字符串的多个副本，会大量使用该操作符时会带来内存和CPU的开销，在Lua中也可以像其他语言一样使用字符串缓存的方式来处理（例如：Java中的StringBuilder，Lua中可以用table.concat）。代码示例如下：local str = ""   local begin_time = os.time() for i=1, 300000 do     str = str  .. "[xxxxxxxxxxx]," end local delay = os.time() - begin_time   print("first delay:" .. delay)   str = "" begin_time = os.time() local buffer = {} for i=1, 300000 do     table.insert(buffer, "[xxxxxxxxxxx]") end   str = table.concat(buffer, ",") delay = os.time() - begin_time print("second delay:" .. delay)   --output --[[ first delay:87 second delay:1 ]]从以上代码的执行结果来看table.concat的方式处理字符串连接非常高效的，普通连接符的方式花了87秒，而table.concat只花了1秒。在实际的开发过程中，我们也需要牢记这一点。 > 长文本字符串定义在其他语言例如Java中定义长文本需要关注文本中的换行和字符转义，Lua提供了一种非常方便的定义方式—— [[长字符串]]。代码示例如下：local a = [[ adfadfadfadf, hello world {     "conio":1,     "b":2,     "c": [         1,2,3     ]   } ]]   print(a)也就是说Lua作为一门嵌入式脚本语言它在处理数据上提供了很多便利的语法糖的。2.2.3.2、字符串标准库常用的方法string标准库中公开的一些常用的方法包括：string.rep, string.reverse, string.lower, string.upper，string.len等。这里主要介绍一下string.gsub, string.pack, string.unpack，主要是因为gsub在一些关键的逻辑使用比较多，string.pack对于二进制字符串打包用于传输的场景使用比较多。> gsub是字符串替换函数，它的第3个参数可以是一个表(table)或者一个function，用于查找和处理替换内容。接下来举一个：下面的示例展示了利用gsub的第3个参数为function时可以将一个字符串解析为另一种table查找的表达方式。这种用法在一些结合查找table元素的场景确实非常有用。这也正是Lua的强大之处。local share_module = {     qq = {         qzone = {             img = function()             end,             text = function(message)                 print("share with content:" .. tostring(message))             end         },         chat = {           }     } }   local share_protocal = function(module, method, text)     local invoke_fun = module     string.gsub(method,'[^\\.]+',function(w)         invoke_fun=invoke_fun[w]     end)       print("share_protocal after gsub:" .. tostring(invoke_fun))     invoke_fun(text) end   share_protocal(share_module, "qq.qzone.text", "hello world")   -- output --[[     share with content:hello world ]]> string.pack和string.unpack这两个函数用于在二进制数据和Lua的基本类型值之间进行转换的函数。string.pack会把值“打包”成二进制字符串，而函数string.unpack是从二进制字符串中提取这些值。关于这个API的参数介绍参考这里。举个栗子：local s = string.pack("s1", "hello") for i=1, #s do     print(string.unpack("B", s, i)) end   -- output --[[ 5   2 104 3 101 4 108 5 108 6 111 7   ]]对于函数里面的format字段的介绍，可以参考这篇文章：链接。s[n]: 长度加内容的字符串，其长度编码为一个 n 字节（默认是个 size_t） 长的无符号整数。上面的示例中 s1 中的 1 代表用一个字节来存放字符串的长度。输出中看出在我们逐个打印每个字节时，第一行是是 "5 2"，表示长度是 "5"，并且 " 2 "代表下一个未读的字节的索引，因为这里是逐个字节读取，所以下一个未读的字节的索引是 2 了。string.pack和string.unpack在网络传输中打包传输字节数组经常使用到，另外在不同的系统之间传递数据也经常使用。将各种类型的数据打包成字节数组来传递，非常的高效和方便。> utf8库从Lua5.3开始，Lua语言引入了一个用于操作UTF-8编码的Unicode字符串的标准库。当然，在引入这个标准库之前，Lua语言也提供了对UTF-8字符串的合理支持。还是以算字符串长度的代码为例：local a = "aaa" local a_len = utf8.len(a)   local b = "你好" local b_len1 = utf8.len(b) local b_len2 = #b local b_len3 = string.len(b)   print("a_len:" .. a_len .. ", b_len1:" .. b_len1 .. ", b_len2:" .. b_len2 .. ", b_len3:" .. b_len3)   -- 输出 -- a_len:3, b_len1:2, b_len2:6, b_len3:6utf8库能正确计算出utf8字符串中字符的个数。 > 模式匹配谈到模式匹配还是挺有意思，为啥Lua搞个自己的模式匹配，为啥不用业内公认的正则表达式呢？原因还是考虑到Lua库的大小。一个典型的POSIX正则表达式实现超过4000行代码，比所有lua语言标准库的总大小的一半还大，lua语言的模式匹配实现代码不到600行。别小看区区600行代码，基本功能一应俱全，已经非常强大了。下面挑了2个我觉得挺不错的点介绍一下：最短匹配符 “-”Lua里面使用了较简单的符号“-”来相对应“+”实现了最短匹配。这个很有用，而在正则表达式中这个字符不是这个含义。这个最短匹配可以用在一段字符串里面出现相同的多个匹配时，匹配最短的场景。例如下面这个例子：local s = "int x; /* 需要去掉的注释内容 */ int y; /* 需要去掉的注释内容 */" local result = string.gsub(s, "/%*.-%*/", "") print(result)   -- output: --[[     int x;  int y;  ]]当文本中有多个注释块需要匹配时不会窜。匹配捕获捕获在正则表达式里面常用“()”括号圈出来。在Lua中会经常用到，例如：匹配并获取到捕获的分组内容匹配并替换捕获到的分组内容下面分别举这两个例子：获取捕获的分组示例：我们将通过分组捕获到的内容逐个赋值给多个变量分别保存起来-- 捕获的副本 local s = [[     I say to everybody: "hello" ]]   local quote_begin, quoted_content, quote_end = string.match(s, "([\"'])(.-)(%1)") print("quote_end:" .. tostring(quote_begin) .. ", what you say:" .. tostring(quoted_content) .. ", quote_end:" .. tostring(quote_end))   -- output: --[[     quote_end:", what you say:hello, quote_end:" ]]Lua语言中支持返回多个结果的特性真的非常方便，省去了像其他语言中需要对数据打包一下，然后用的地方解包的过程。上面的例子中把捕获的结果直接获取并直接赋值给多个结果，代码是不是非常简洁易懂～。替换捕获分组示例：Lua中的字符串替换函数是 gsub，下面的例子用到了gsub，且用到了 %n 这样的匹配具体的第几个捕获，可以使用的场景非常多。例如下面这个将查找到的字符串换成另外一种表达形式：local s = [[     "lily-girl". "Tom-boy", we are twins ]]   local result = string.gsub(s, "\"([%a]+)-([%a]+)\"", "Hello my name is %1 and I'm %2") print(result)   -- output --[[     Hello my name is lily and I'm girl. Hello my name is Tom and I'm boy, we are twins ]]另外我们通过gsub再来实现string.trim的功能。trim方法用于去除字符串前后多余的空格，在这里我们也用到了 %n 这样的匹配捕获的方式，将捕获到的不包含前后空格字符的内容替换之前的内容，这样实现了trim的功能。代码示例如下：local s = " adfafadfadfad    "   local result = string.gsub(s, "^%s*(.-)%s*$", "%1") print(result)   --output: --[[ adfafadfadfad ]]再举一个使用场景的例子，替换字符串中的占位符。这里的做法是将文本中$(%a+)出现的内容视为占位符，然后捕获括号里面的%a+表示的占位符名称。接下来用到了gsub的第三个参数为table类型的情况，gsub会用捕获到的值作为参数在table（这里是variable）里面查找，将查找到的值作为待替换的内容去替换gsub里面第二个参数匹配到的内容。local s = [[     Hello, my name is $name, and I like $food ]]   local variable = {     name = "Tom",     food = "Pizza" }   local result = string.gsub(s, "$(%a+)", variable) print(result)   --output: --[[     Hello, my name is Tom, and I like Pizza ]]2.2.4、table这个类型十分强大，它是Lua里面主要的数据结构，他可以用来实现其它语言中的常见的数据结构：Map，集合，数组，记录等。下面列举了table使用中我们需要留意的几个点：2.2.4.1、table中的keytable的key可以是除了nil意外的任意值，也就是说它可以是字符串，数值，甚至是table。当用到table作为key时，就出现了一个非常有用的唯一key的用法。为了避免table中的key冲突，可以使用table对象作为key（因为table对象的地址是唯一的），代码示例如下：local a = {}   local unique_key = {} a[true] = 2 a[unique_key] = 3   for key, val in pairs(a) do     print("key:" .. tostring(key) .. ", val:" .. tostring(val)) end   --output --[[ key:table: 0x7ffd9a4096f0, val:3 key:true, val:2 ]]我们还可以通过把值设置为nil来从table中删除一条记录。2.2.4.2、table中元素的安全访问在其它语言中在访问某个可能为空的对象里面的属性时会用到三目运算符，但是Lua中没有这个运算符。Lua作者推荐我们另一种方式来实现类似的操作：local a = {     b = {         c = {}     } }   -- 安全访问 a.b.c.d   local d = (((a or {}).b or {}).c or {}).d   print("d:" .. tostring(d)) -- output -- d:nil2.2.4.3、table的长度计算table的长度也可以用计算string长度的”#”操作符来完成，不过需要记住的是对于table计算长度，这个table最好是个数组，而不是包含其他非连续整形类型的集合，如果对这样的集合算长度会得到不可预知的结果。下面列举了3个计算table长度的示例：print("---------------seperator------------------") a = {} a[1] = 1 a[2] = nil a[3] = 2 a[4] = 3 a[5] = nil   print("table len:" .. #a)   -- output:: -- table len:4   print("---------------seperator------------------") a = {} a[1] = 1 a[10000] = 1 print("table2 len:" .. #a)   -- output: -- table2 len:1   print("---------------seperator------------------") a = {} a[1] = 1 a["b"] = 2 a[3] = 2 a[4] = 3 print("table3 len:" .. #a)   for _index, value in ipairs(a) do     print("_index:" .. _index .. ", value:" .. tostring(value)) end   -- output: -- table3 len:4 --_index:1, value:1我们知道table里面把值设置为nil代表从table中删除该元素，对于上面示例中的table2场景，究竟是之前有10000个值，后面把数组中间的值设置为了nil，还是本身这个table就只有包含2个key的元素呢，我们看到的结果是这个table的长度返回了1，是不是比较难理解。所以还是那句话计算table的长度时，我们最好能确认这个table是一个包含连续整形索引的数组。Lua中的数组是从1开始的，不过你可以定义任意数值的key。2.2.4.4、使用pairs和ipairs遍历一个tableLua中遍历一个table可以用 in pairs 或者 in ipairs，还可以用下面这个，具体怎么使用参考这里。for var=exp1,exp2,exp3 do       <执行体>   end这里我主要介绍一下pairs和ipairs，因为lua里面的table结构比较强大，可以用来表示其它语言里面多种结构，包括：数组，map，集合，记录等。当我们的table表示一个数组时可以用ipairs，不过使用ipairs有一些限制：ipairs的key需要是数值类型，非数值类型会被忽略索引的顺序是确定的从1开始的连续增序分布所以需要注意：不要用ipairs遍历一个非连续整数索引的table当一个table为一个集合或map时，可以使用pairs。它没有ipairs这些限制，不过也要注意：使用pairs遍历集合里面的nil记录会被跳过。下面这个示例是分别使用ipairs和pairs遍历一个包含任意类型的集合：a = {     [0]="zero", "a", 1, [5] = {}, nil, 3 }   for _index, value in ipairs(a) do     print("_index:" .. _index .. ", value:" .. tostring(value)) end   -- 输出 --[[ _index:1, value:a _index:2, value:1 ]]   print("---------------seperator------------------") for _key, value in pairs(a) do     print("key:" .. tostring(_key) .. ", value:" .. tostring(value)) end   -- 输出 --[[ key:1, value:a key:2, value:1 key:4, value:3 key:0, value:zero key:5, value:table: 0x7fb8ecc098b0 ]]示例中我们使用pairs时能遍历到table中的除了nil的其他所有值。但是遍历的顺序并不是table中原始的顺序。同时上面的示例也印证了我上面提到的限制。这说明对于一个自由度较高的table我们也并非可以任意发挥，我们要知道table是什么样的结构，我们可以采用什么方式来遍历。2.2.4.5、table的标准库lua也提供了标准库用于操作table，常用的api有：table.insert, table.remove, table.move, table.sort等，这些api对于table的操作都非常有用。这里列举一个table排序的例子，我们知道table结构的自由度很高，所以对个table排序可以自定义：local a = {     {         name = "jack",         score = 100     },     {         name = "jack2",         score = 98     },     {         name = "sam",         score = 35     },     {         name = "tom",         score = 78     } }   table.sort(a, function(_a, _b)     return _a.score > _b.score end)   for index, t in ipairs(a) do     print("name:" .. tostring(t.name) .. ", score:" .. tostring(t.score)) end   -- output --[[ name:jack, score:100 name:jack2, score:98 name:tom, score:78 name:sam, score:35 ]]另外想重点介绍一下另外两个api: table.pack 和 table.unpack，为什么想介绍这两个api，因为他们在其它语言是没有的，所以比较特别，但是它们在Lua中应运而生。我理解由于Lua的函数入参支持可变参数，函数的返回也支持返回多个，因为这些强大的能力，所以孕育出了table.pack和table.unpack这样的api。它们的主要用途是对一个包含任意类型的集合拆成单个项，也可以反过来打包成一个集合结构。以一个示例来描述：local f1 = function(...)     local params_table = table.pack(...)     local params_table2 = params_table     return params_table2 end   local packed_data = f1(nil, 1, {}, nil, function() end, 3) local a, b, c, d, e, f = table.unpack(packed_data) print("params a:" .. tostring(a) .. ", b:" .. tostring(b) .. ", c:" .. tostring(c) .. ", d:" .. tostring(d) .. ", e:" .. tostring(e) .. ", f:" .. tostring(f))   --output --params a:nil, b:1, c:table: 0x7f945dc09940, d:nil, e:function: 0x7f945dc07ca0, f:3 print("---------------seperator------------------")   packed_data = f1(nil, 2, nil) local a,b,c = table.unpack(packed_data) print("params a:" .. tostring(a) .. ", b:" .. tostring(b) .. ", c:" .. tostring(c))   --output -- params a:nil, b:2, c:nil上面这个示例展示了包含任意类型的集合可以打散成一个个的项，也可以反过来把这些项打包到一个table里面。这个api适用于lua语言的可变参数和多结果返回的特性。另外上面的示例中local params_table = table.pack(…)的写法也可以简单的换位local params_table = {…}，这样的语法糖对于编程是非常便利的。这里也可以看出Lua在处理编程细节方面考虑了很多，这也体现出它对这个语言设计的初衷：简洁轻量，机制重于规则约束。2.2.4.6、table.pack和unpack的使用特别注意这里标红一下，在使用table的pack和unpack时容易踩到一个坑，我们看一个例子：local table2 = {     [1] = "http://www.baidu.com",     [2] = {     },     [3] = {        ["product_name"] = "1",        ["cp_order_id"] = "123",        ["app_name"] = "demo1",        ["order_amount"] = "0.01"     },     [5] = function() end,     [6] = function() end }   local table3 = {     "http://www.baidu.com",     {},     {        ["product_name"] = "2",        ["cp_order_id"] = "123",        ["app_name"] = "demo2",        ["order_amount"] = "0.01"     },     nil,     function() end,     function() end }   local v1, v2, v3, v4, v5, v6 = table.unpack(table2) print("table2: v1:" .. tostring(v1) .. ", v2:" .. tostring(v2) .. ", v3:" .. tostring(v3) .. ", v4:" .. tostring(v4) .. ", v5:" .. tostring(v5) .. ", v6:" .. tostring(v6))   v1, v2, v3, v4, v5, v6 = table.unpack(table3) print("table3: v1:" .. tostring(v1) .. ", v2:" .. tostring(v2) .. ", v3:" .. tostring(v3) .. ", v4:" .. tostring(v4) .. ", v5:" .. tostring(v5) .. ", v6:" .. tostring(v6))   --output --[[ table2: v1:http://www.baidu.com, v2:table: 0x7f8dfb40b3f0, v3:table: 0x7f8dfb40b430, v4:nil, v5:nil, v6:nil table3: v1:http://www.baidu.com, v2:table: 0x7f8dfb40b5b0, v3:table: 0x7f8dfb40b5f0, v4:nil, v5:function: 0x7f8dfb40b690, v6:function: 0x7f8dfb40b6b0 ]]上面的示例中table2和table3其实表达的意思相同，但是unpack的结果却不一样。主要计算table的长度时我们需要明确的知道它是一个数组，中间不要有nil，不然结果会匪夷所思。可以从这篇文章了解一下：链接。推荐做法：将key明确的设置为字符串可以避免上面的问题-- 避免数组出现nil，参数最多个数为8个 local function param_encode(v1, v2, v3, v4, v5, v6, v7, v8, ...)     assert(#{...} == 0, "参数不能大于8")     return {         v1 = v1,         v2 = v2,         v3 = v3,         v4 = v4,         v5 = v5,         v6 = v6,         v7 = v7,         v8 = v8     } end local function param_decode(tb)     return tb.v1, tb.v2, tb.v3, tb.v4, tb.v5, tb.v6, tb.v7, tb.v8 end2.2.4.6、元表和元方法Lua设计了元表和元方法，它的目的在于：用于拓展任意值在面对一个未知操作时的行为。这个机制不仅仅可以作用于table，甚至可以作用于基本类型，但是在Lua脚本中我们改变不了基本类型的元操作行为，不过可以在C层实现。这里先提一下，抛出这个概念，让我们提前有个印象。因为table除了结构强大，他还能实现类似其他脚本或面向对象语言的方法原型、继承等概念，这些概念依赖元机制，用到table必然会用到元机制。更详细的我们在下面的元机制中介绍。下面展示了元机制实现的两个table相加，table和其它类型数值相加的示例：local tb1 = {1,2,3} local tb2 = {'a','b','c'}   local mt = {     __add = function(a, b)         local result = {}         for _index, value in ipairs(a) do             table.insert(result, value)         end           if type(b) == "table" then             for _index, value in ipairs(b) do                 table.insert(result, value)             end         else             table.insert(result, b)         end                  return result     end } setmetatable(tb1, mt) setmetatable(tb2, mt)   local b = tb1 + tb2 for _ind, val in ipairs(b) do     print("index:" .. _ind .. ", value:" .. tostring(val)) end   --output --[[ index:1, value:1 index:2, value:2 index:3, value:3 index:4, value:a index:5, value:b index:6, value:c ]]上面的示例中为table添加了元表(setmetatable)，这个元表里面添加了元方法_add(Lua语言里面定义了一些操作符的元方法名称例如_div表示除法)。该元方法的入参是对应”+”的两个操作数，我们可以自定义实现我们想要怎么做，例如这里我们假设第一个操作数是table, 希望如果第二个操作数是table则合并到第一个table，第二个操作数是其他类型则直接插入到第一个table中。看到输出结果能满足我们这个想法。我们再试试将一个table和一个number类型的数据相加会怎么样：local result2 = tb1 + 111 for _ind, val in ipairs(result2) do     print("index:" .. _ind .. ", value:" .. tostring(val)) end   --output --[[ index:1, value:1 index:2, value:2 index:3, value:3 index:4, value:111 ]]是不是也是符合预期的。这里简单的过了一下元机制，以及它在table结构中的应用。详细了解元机制可以看下面的元机制的介绍。 2.2.5、functionfunction在Lua语言是lua是“第一类值”，Lua中所有的函数都是匿名的，不仅可以存储在全局变量中，还可以存储在表字段和局部变量中。同时上面介绍全局变量的时候有提到Lua语言把所有的代码段都当作匿名函数，而同时也会把_ENV作为该匿名函数的上值绑定到该匿名函数。lua中有三类函数：大类都是LUA_TFUNCTION，变体分别是LUA_VLCL(Lua closure)、LUA_VLCF(light C function)、LUA_VCCL(C closure)lua的closure是下面这个样子的，它包括：函数原型（编译后的包含指令信息的字节码块）和上下文环境。上下文环境包括：upvalues（上值）和 env（所在环境）。 env就是上面提到的_ENV，它可以在loadfile时指定，不指定的时候默认会设置为全局表_G。想要指定某个closure的_env可以这么做：env = {} loadfile("xxx.lua", "t", env)()loadfile会返回一个function类型的closure，所以会再加上一个()用于执行该closure。在上面这个示例中我们指定了环境为一个空table，修改了closure的环境。这个在某种意义上起到了沙盒的作用，也就是这个加载的lua脚本的环境是空的，它无法访问C层的库，也就是脚本只能执行自己的业务。那上值是啥？简单的说它是closure特有的，当创建一个closure时可以给他绑定一些值，这些值在该closure内可以访问，这些值就是上值。其实看c function的宏定义可以知道它其实也是closure类型，只是上值固定为0。所以作者说lua中只有闭包没有函数，总结来说闭包 = 函数+若干个上值（up value）。更多上值相关的介绍看官方的这篇文章：链接。 2.2.5.1、lua function和 c function的区别lua function脚本会预编译成字节码，然后存储为function类型值，而c_function需要通过lua c api注册给lua使用。详细见这篇文章：链接对于CClosure数据结构(C闭包函数)：lua_CFunction f：函数指针，指向自定义的C函数TValue upvalue[1]：C的闭包中，用户绑定的任意数量个upvalue对于LClosure数据结构(Lua脚本函数)：Proto *p：Lua的函数原型，在下面会有详细说明UpVal *upvals：Lua的函数upvalue，这里的类型是UpVal，这个数据结构下面会详细说明，这里之所以不直接用TValue是因为具体实现需要一些额外数据。2.2.5.2、重定义函数了解了Lua中的function是什么，我们了解一下function在Lua语言中使用上的一些特点。从上面我们了解到我们Lua脚本中引用的全局变量和全局方法实际是从上下文环境_ENV的table中获取的。我们可以把这个全局table中的方法替换成任意其它值，这里介绍一种在Lua中经常用的hook方式编程。以下示例展示了脚本hook了全局方法，并在方法里面额外做了一些事情：local origin_print = print print = function(message)     if type(message) == "table" then         local buff = {}         for k, v in pairs(message) do             table.insert(buff, k .. ":" .. v)         end                  local result_msg = table.concat(buff, ",")         origin_print("hooked print:" .. tostring(result_msg))     else         origin_print("hooked print:" .. tostring(message))     end end   print({a=1, b=2, c=3})   -- not forget to set back print = origin_print   -- output: --[[     hooked print:b:2,c:3,a:1 ]] 2.2.5.3、多参数返回和函数可变入参Lua的function可以有多个返回值，入参支持可变参数。这个特性挺巧妙的，在使用方面会带来很多的便利，主要体现在以下几个方面：多返回值省去了对结果的包装：在Java语言中多个返回结果我们会用Pair, Object, Map, Json等进行包装，Lua中只要直接返回多个数据值就好。变参入参巧妙的达到了方法重载的目的。如果一个同名方法想要再拓展一个或多个参数，在Java语言中需要用重载多个方法来实现。Lua语言中可以直接往后面加。如果有不确定的多个参数，那么Lua可以让你使用”…”来替代参数定义。多个参数返回和可变参数的函数入参这两个特性结合在一起，又省去了处理函数返回解析逻辑的这一开发工作，提升了效率。这些语言中的细节点，或者语法糖，体现出了作者从语言设计之初到完成整个设计过程中的始终不忘的初心——简洁和轻量。程序员能不爱不释手吗？下面对这几个特性分别列举几个示例：多参数返回：local test2 = function()     return 1, "hello", true, { name = "Jack"} end   local a1 = test2() print("a1:" .. tostring(a1)) local a1, a2, a3 = test2() print("a1:" .. tostring(a1) .. ", a2:" .. tostring(a2) .. ", a3:" .. tostring(a3))  local a1, a2, a3, a4, a5= test2() print("a1:" .. tostring(a1) .. ", a2:" .. tostring(a2) .. ", a3:" .. tostring(a3) .. ",a4:" .. tostring(a4) .. ",a5:" .. tostring(a5))   --output --[[ a1:1 a1:1, a2:hello, a3:true a1:1, a2:hello, a3:true,a4:table: 0x7fc52bd087b0,a5:nil ]]这个示例体现出的一个使用方法是，你可以根据你关心的某几个返回值来决定定义的容纳这些数值的变量，其它的不取则默认丢弃。在其他的一些语言中你要首先解析出所有的参数，然后再决定想取某几个。2. 可变入参local handle_result = function(succ, ...)     if succ then         local ret_data = ...         print("result:" .. tostring(succ) .. ", data:" .. ret_data)     else         local code, msg = ...         print("result:" .. tostring(succ) .. ", code:" .. tostring(code) .. ", msg:" .. tostring(msg))     end end   handle_result(true, "this is true result") handle_result(false, 404, "not found")   --output --[[ result:true, data:this is true result result:false, code:404, msg:not found ]]根据参数的不同值来决定其他数据是什么，在可变参数这个特性出现后变得更容易实现了。3. 两者的结合lua模块加载方法load，标准库里面的file，io等提供的API返回值都遵循共同的一个约定，如果成功则返回对应内容，如果失败则返回nil + 错误信息。看的出来这个约定会根据不同的情况返回不同的内容，那么就是作为函数返回值是动态的，并可能有多个返回值，作为另一个函数的入参它是动态的，并可能有多个参数传入。而assert函数的执行会先判断第一个参数如果不为true（下一节会介绍Lua中除了nil和false的值其它都是true），则会认为第二个参数为错误信息。如果第一个参数校验为true则返回函数的执行结果，不作处理。这个assert方法就巧妙的结合了函数的多结果返回，和函数的可变参数入参实现了断言。设计细节如此精妙，不经让人拍案叫绝～function dofile (filename)     local f, err = assert(loadfile(filename))     if f then         f()     end   end     dofile("helloxxx.lua")      --output   --[[ lua: function_test2.lua:43: cannot open helloxxx.lua: No such file or directory stack traceback:     [C]: in function 'assert'     function_test2.lua:43: in function 'dofile'     function_test2.lua:49: in main chunk     [C]: in ?   ]]2.2.5.4、Lua C function所有在Lua中注册的函数都必须使用一个相同的原型，该原型就是定义在 lua.h 中lua_CFunction:/* ** Type for C functions registered with Lua */ typedef int (*lua_CFunction) (lua_State *L);从C语言的角度看，这个函数只有一个指向Lua状态类型的指针作为参数，返回值是一个整型数，代表压入栈中的返回值的个数。因此，该函数在压入结果前无需清空栈。在该函数返回后，Lua会自动保存返回值的并清空整个栈。如果我们有多个lua c function，我们希望把这些lua c function放在一个table里面一起返回给Lua。Lua语言中提供了luaL_Reg类型，该类型是由两个字段组成的结构体，这两个字段分别是函数名（字符串）和函数指针。luaL_Reg reg[] = {             {"log", _log},             {NULL, NULL} /* 哨兵 */     };在上面的例子中，只声明了一个函数（log）。数组的最后一个元素永远是{NULL, NULL}，并以此标识数组的结尾。最后，我们使用函数luaL_newlib声明一个主函数：int luaopen_mylib(lua_State *L) {   luaL_newlib(L,reg);   return 1; }对函数luaL_newlib的调用会新创建一个表，并使用由数组reg指定的“函数名-函数指针”填充这个新创建的表。当luaL_newlib返回时，它把这个新创建的表留在了栈中。然后，函数 luaopen_mylib返回1，表示将这个表返回给lua。 2.2.6、booleanboolean类型中true在Lua里面是除false和nil之外的值，例如：0和空字符串是真2.2.7、userdatauserdata 表示一个原始的内存块，可以有自己的metatable，这个metatable可以绑定到该userdata(内存块)，然后在Lua脚本中通过元表来操作这个userdata。本篇文章下面介绍C接口时会有一个userdata的示例，想了解的可以继续往下阅读。2.2.8、thread在Lua 中thread代表独立执行的任务，在Lua中是通过协程来实现的。它和操作系统的线程不同，协程可以在所有的系统上面支持协程，即使是那些不支持线程的系统。这里就不做详细的介绍了，想了解的可以可以参考官方的介绍：链接 2.3、Lua常用到的语法2.3.1、goto可以从定义的标签的地方继续执行，虽然说goto在编程语言中不被人推荐，主要是因为它破坏代码逻辑的结构。这里介绍它在Lua脚本中的一个有用的使用方法。我们知道Lua中的迭代器没有continue字段，我们可以通过goto来实现continue。Lua中的标签是通过被两个“::”包围的标签名字符串来表示的，代码示例如下，他是通过goto让Lua的代码执行直接切换到该标签处：local arr = {     "a_value",     "b_value",     "c_value" }   local f1 = function()     for _index, value in ipairs(arr) do         print("loop key:" .. value)         print("begin compare:" .. _index)         if value == 'b_value' then             print("find b then goto find_task")             goto find_task         else             print("not find and continue1")             goto continue         end              ::find_task:: do             print("find b and return")             return         end           ::continue:: do             print("not find and continue2")         end     end end   f1()   -- output: --[[ loop key:a_value begin compare:1 not find and continue1 not find and continue2 loop key:b_value begin compare:2 find b then goto find_task find b and return ]]2.3.2、三目运算Lua中没有三目运算符，也就是它没有提供诸如Java中这样的写法：String s = a > b ? “s1” : “s2”; 但是Lua有一种替代的写法：local s = (a>b) and "s1" or "s2"之所以能这样做是因为Lua中的and和or逻辑运算符也遵循最短路径。例如这样的判断逻辑是不会出错的（不会因为i的值为0了导致算数运算符出现除0的错误）：i ~=0 and a/i > b --正常运行在Lua中使用上面的三目运算方式需要注意一点——lua中nil和false值会判断为false，其它的任意值会判断为true，所以我们需要留意and 前面这个判断不能出现歧义。例如下面这种写法就不应该用这样方式实现三目运算符：local b = 2 > 1 and nil or "here" print(b)   --output --[[     here ]]2.4、Lua虚拟机前面1.1.1章节介绍了Lua虚拟机在Lua语言中的依赖关系以及它自身的组成。我们再回顾一下，它包括2个部分：global_state（全局状态）和lua_state（负责Lua脚本和Lua c function的执行，包括它们之间的数据交换）。 lua_state包括方法调用栈和数据栈。那么Lua虚拟机在Lua语言中的角色是什么呢？首先我们先了解什么是虚拟机，”虚拟机”就是使用代码实现的用于模拟计算机运行的程序. 每一门脚本语言都会有自己定义的opcode(operation code,中文一般翻译为”操作码”)，可以理解为这门程序自己定义的”汇编语言”。我们了解到对于编译型语言，比如C等，经过编译器编译之后生成的都是与当前硬件环境相匹配的汇编代码；而脚本型的语言，经过编译器的处理之后，生成的就是opcode，再将该opcode放在这门语言的虚拟机中逐个执行.。可见，虚拟机是个中间层，它处于脚本语言前端和硬件之间的一个程序(有些虚拟机是作为单独的程序独立存在，例如Java。而Lua由于是一门嵌入式的语言是附着在宿主环境中的，它的Lua虚拟机是C代码实现的，被编译在宿主程序中，由宿主程序加载和启动).Lua虚拟机的依赖关系图：lua对外通过lua.h, lauxlib.h对外公开API接口。虚拟机部分主要包括global_state和 lua_state两个部分，其中lua_state包括stack数据栈和base_ci、ci指向的函数调用链。lua虚拟机的主要职责是执行字节码中的指令，管理全局状态（global_state）和函数调用链状态(base_ci, ci)，在stack中处理指令执行过程中的数据（TValue数组）。Lua虚拟机具体的工作流程：步骤一：从C层开始，我们通常加载一个Lua脚本是通过luaL_dofile来执行一个脚本文件。这个dofile操作包括load_file和pcall两部分组成。我们看到它的宏定义是这样的：(lauxlib.h) #define luaL_dofile(L, fn) \   (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))load_file实际是解析Lua脚本文件，转换成字节码chunk并作为一个C的closure返回，源码如下(ldo.c)：static void f_parser (lua_State *L, void *ud) {   int i;   Proto *tf;   Closure *cl;   struct SParser *p = cast(struct SParser *, ud);   int c = luaZ_lookahead(p->z);   luaC_checkGC(L);   tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,                                                              &p->buff, p->name);   cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));   cl->l.p = tf;   for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */     cl->l.upvals[i] = luaF_newupval(L);   setclvalue(L, L->top, cl);   incr_top(L); }步骤二：执行前面步骤通过setclvalue压在栈里面的closureLUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {   struct CallS c;   int status;   ptrdiff_t func;   lua_lock(L);   api_checknelems(L, nargs+1);   checkresults(L, nargs, nresults);   if (errfunc == 0)     func = 0;   else {     StkId o = index2adr(L, errfunc);     api_checkvalidindex(L, o);     func = savestack(L, o);   }   c.func = L->top - (nargs+1);  /* function to be called */   c.nresults = nresults;   status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);   adjustresults(L, nresults);   lua_unlock(L);   return status; }步骤三：接下来luaD_call会执行luaD_precall，再到luaV_execute;luaD_precall: 会检查CallInfo调用链表，如果首次调用，那么该链表为空会创建第一个CallInfoluaV_execute: 这里是虚拟机执行代码的主函数。这里会一直循环从ci的指令列表中取出指令逐个执行整体的流程如下： 2.4.1、栈为啥会有栈呢？它是C和Lua之间调用的通道。当我们想在Lua和C之间交换数据时，会面对两个问题：动态类型和静态类型体系之间不匹配自动内存管理和手动内存管理之间不匹配此外Lua语言不仅能方便的与C/C++交互，而且还能与Java、Fortran、C#等其他语言方便的交互。其次，Lua会做垃圾收集，由于Lua语言引擎并不知道Lua中的一个表可能被保存在一个C语言变量中，因为它可能会错误的认为这个表可以被回收。栈的存在形式是做为一个StkId，实际是一个TValue的指针。TValue是个包含type信息和union类型的一个结构。用于表示lua中的数据类型。CAPI使用索引来引用栈中的元素，第一个被压入栈的元素索引为1， 第二个被压入的元素索引为2，依次类推。我们还可以以栈顶为参照，使用负数索引来访问栈中的元素。此时，-1表示栈顶元素（即被最后压入的元素），-2表示在它之前被压入栈的元素，依此类推。例如：调用lua_tostring(L, -1)会将栈顶的值作为字符串返回。当Lua调用C注册的方法时，Lua的参数会先压栈，例如一个Lua调用C的例子：lua示例：该Lua调用C方法时传入了4个参数，分别对应3个string类型，第4个是字节数组（在lua里面的字符串可以存储任意编码的字节数组）。在调用到C方法时Lua会分配一个新的栈，并把这些参数按照顺序逐个压栈，例如：M.JAVA_CALL_STATIC_CLASS会压入到栈索引1的位置，type字符串会放在栈索引2的位置，依此类推。function M.invoke(type, params, chunk)     params = params or {}     chunk = chunk or ''     local json_str = JSON.encode(params)     local ret = conio.invoke(M.JAVA_CALL_STATIC_CLASS, type, json_str, chunk)     return ret end在C方法接收到调用时我们想要获取传入的参数，可以从栈里面按照索引逐个弹出参数，例如下面方法体的前5行代码：C示例：static int _invoke(lua_State* L) {     const char* cls = luaL_checkstring(L, 1);     const char* call_ = luaL_checkstring(L, 2);     const char* params_ = luaL_checkstring(L, 3);     size_t chunk_len;     const char* chunk_ = luaL_checklstring(L, 4, &chunk_len);     ...     lua_pushnumber(L, 1);     return 1; }我们注意到方法的最后两行是压入了一个number类型的数值，同时返回了1。这是告诉Lua在收到C方法返回时栈里面留下了1个返回结果。Lua脚本可以直接从C方法调用返回值赋值给lua变量。2.4.1.1、栈平衡编写C代码时保持栈平衡是一个非常好的习惯，不然操作完栈后由于一些数据不小心留在了栈中，在其他逻辑处理时从栈中pop出来的数据就不是我们意料之中的，那么会出现奇奇怪怪的问题。下面举一个保持栈平衡的例子：void onLuaError(lua_State *L) {     int top = lua_gettop(L);     const char *msg = lua_tostring(L, 1);     if (msg == NULL) {  /* is error object not a string? */         if (luaL_callmeta(L, 1, "__tostring") &&  /* does it have a metamethod */             lua_type(L, -1) == LUA_TSTRING)  /* that produces a string? */             ;  /* that is the message */         else             msg = lua_pushfstring(L, "(error object is a %s value)",                                   luaL_typename(L, 1));           error_stat("lua", "exception", msg, lua_tostring(L, -1), NULL, NULL);         lua_settop(L, top);         return;     }       luaL_traceback(L, L, msg, 1);  /* append a standard traceback */     const char * stack_trace = lua_tostring(L, -1);     error_stat("lua", "exception", msg, stack_trace, NULL, NULL);     lua_settop(L, top); }方法调用开始前我们获得了栈的当前位置，处理了一系列的压栈操作后我们通过lua_settop方法设置回之前的栈的位置，保持了栈平衡。 2.5、Lua中的机制正如Lua提到它的设计原则遵循尽量使用机制来代替规则约定，Lua内置了一些非常有用的机制来帮助管理代码模块，内存分配等这些繁琐，且容易出错的内容。2.5.1、模块和包管理机制谈到模块和包，我们一般想到的是我们对代码逻辑的划分，然后这些划分之后的独立模块，能支持不同路径动态查找、按需加载和卸载、更新替换等。Lua中的模块包括：Lua脚本模块和使用C接口扩展3方模块。用一个图描述一下如下：流程描述：首先，函数require在表package.loaded中检查模块是否已经被加载。如果模块已经加载，函数require就返回相应的值。因此，一旦一个模块被加载过，后续对于同一模块的所有require调用都将返回同一个值，而不会再运行模块里面的代码。如果package.loaded里面没有（即没有加载），那么函数require会去检查package.preload，这个里面定义了模块名和加载函数的映射（这里再统一一下概念加载函数是一个函数类型，可以被执行，能返回模块需要返回给外部的公开数据，由模块自己决定返回内容，通常会是一个table，也可以是其他值。如果返回nil，为了保证package.loaded里面能记录该模块被加载过，会填补一个true值，例如：package.loaded[模块名]=true ）。使用到的场景有：当我们使用静态链接到Lua的C库，可以将其luaopen_函数注册到preload里面，这样luaopen_函数只有当用户加载这个模块时才会被调用。 前面2部没有找到时，Lua会去搜索该模块的文件，首先尝试搜索lua文件路径。该搜索路径是由变量package.path指定。通过该搜索路径如果找到了相应的文件，那么就用函数loadfile进行加载，该函数的返回结果是加载函数。接下来简单介绍一下package.path，在ISO C并没有目录的概念。所以package.path使用的是一组模版（template）,例如： ?;?.lua;c:\windows\?;/usr/local/lua/?/?.lua自定义package.path示例：static void register_lua_search_path(lua_State* L, const std::string& path) {   lua_getglobal(L, "package");   lua_getfield(L, -1, "path");   std::string cur_path = luaL_checkstring(L, -1);   cur_path.append(";");   cur_path.append(path);   lua_pop(L, 1);   lua_pushstring(L, cur_path.c_str());   lua_setfield(L, -2, "path");   lua_pop(L, 1); }   static int init_lua_path(lua_State* L) {   register_lua_search_path(L,  ".\\..\\..\\my_lua\\?.lua" + ";" +  + ".\\..\\..\\my_lua\\?\\?.lua");   return 0; }如果找不到指定模块的Lua文件，那么它就会搜索相应名称的C标准库（此时，搜索路径由变量package.cpath指定）。如果找到一个C标准库，则会使用底层函数package.loadlib来进行加载，这个底层函数会查找名为luaopen_模块名的函数。此时的加载函数就是loadlib的执行结果，也就是一个被表示为Lua函数的C语言函数luaopen_模块名。以上都是Lua系统的默认的查找方式，如果程序有一些特别的查找方式，例如需要解开一个zip包后拿到文件等，Lua提供了一个搜索器的概念。Lua提供的搜索器是由package.searchers提供。函数require会传入模块名并调用该列表中的每一个搜索器直到它们其中的一个找到了指定模块的加载器（即能正常返回加载函数）。如果所有的搜索器都被调用完后还是找不到，那么函数require就抛出一个异常。自定义searcher搜索器比较简单，我们只需要往package.searchers表里面插入一个function，然后该function的实现需要接收一个模块名的参数，并能返回一个加载函数。示例如下： -- Lua 5.2 package.searchers     local function loader(name)         local ret, content, modpath = pcall(read_with_module_name, name)         assert(ret, "file not found " .. modpath .. '@' .. name)         local ret2 = assert(load(content, modpath, 'bt'), "source error ".. modpath)(name)         if ret2 then             return ret2         end     end       table.insert(package.searchers, function(_name)         return loader     end)2.5.1.1、Lua模块和C模块我们先搞清楚模块是啥。从用户的观点来看，一个模块（module）就是一些代码（要么是Lua语言编写的，要么是C语言编写的），这些代码可以通过函数require加载，然后创建和返回一个表。这个表就像是某个命名空间，其中定义的内容是模块中导出的东西，比如函数和常量。以Lua举例，通常Lua的模块是什么样的：lua module例子：local a = 0 local M = {} M.get_a = function()     a = a + 1 return a end   return M外部调用该模块示例：local a = require "test_module.module1" print(a.get_a())上面例子可以看出我们在module的代码中定义了一个table M，这个table用于定义该模块可以公开的一些内容，例如模块中定义了get_a方法，然后该模块将M表作为require函数加载过程中的加载函数执行结果返回，按照上面讲解的require机制的流程，该结果也会存储一份到package.loaded，用于其他代码require时能直接返回，而不需要再次执行模块代码。这种Lua模块的包装方式是Lua推荐的一种比较简单的方式，从模块的包装我们可以清晰的知道定义在M表结构里面的方法和常量是模块希望对外的，而没有在M里面local变量则可以认为是私有变量，他们是不希望对外的。例如上面示例中的local a。另外有时我们遇到一种场景，就是M中定义的函数访问另一个私有函数时，该函数已经定义在文件的末尾，也就是没有提前申明，该M里面的函数就找不到那个私有函数，如果把这个私有函数挪动位置放在最前面那么会动到之前的代码，这样就不是很好。我们可以把私有函数前面也加上M.这样可以不挪动私有函数的位置从而被定义在前面的M.的函数访问。但是为了表明该函数是私有的，我们可以在私有名称的最前面或者最后加上一个下划线，用于约定区分全局名称。 接下来介绍一下C模块的包装示例：Lua提供了4种方式:方式1： 动态链接库的方式。路径中添加“模块名”.so（Android环境），so中定义了函数luaopen_模块名，这样Lua可以在脚本中直接require “模块名”得到luaopen_模块名返回的值。下面举个例子：local cjson = require "cjson" local json_str = [[{"a":"hello lua lib decode!"}]] local decode_ret = cjson.decode(json_str) print(decode_ret.a)   local json_tbl = { a = "hello lua lib encode!"} local encode_str = cjson.encode(json_tbl) print(encode_str)   --output: --[[ hello lua lib decode! {"a":"hello lua lib encode!"} ]]上面的例子中我们将Lua的cjson库下载下来（下载地址：链接），编译后生成cjson.so文件，然后放在Lua工程的目录下面命名也是cjson.so，这命名和require “cjson”的cjson是相同的，从上面的加载机制我们了解到require函数会通过模版的方式在当前的路径下面找到cjson.so，并加载进来，同时查找luaopen_cjson方法并执行它得到的结果返回Lua同时存放在package.loaded。从上面的示例我们可以看到Lua脚本就能正确调用到cjson模块暴露的decode和encode方法了。我们简单看一下cjson的luaopen_cjson方法：int luaopen_cjson(lua_State *l) {     lua_cjson_new(l);   #ifdef ENABLE_CJSON_GLOBAL     /* Register a global "cjson" table. */     lua_pushvalue(l, -1);     lua_setglobal(l, CJSON_MODNAME); #endif       /* Return cjson table */     return 1; }我们看到luaopen_cjson方法返回了一个table，这个table就是lua脚本获得的值。lua中调用decode和encode就是调用的这个table里面的对应的两个方法了。此时我们把模块名改成cjson2会发生什么呢？就会报一个找不到的错误了：--[[ ua: error loading module 'cjson2' from file './cjson2.so':     dlsym(0x7fda99c09c90, luaopen_cjson2): symbol not found stack traceback:     [C]: in ?     [C]: in function 'require'     test_so.lua:1: in main chunk     [C]: in ? ]] 方式二：添加到lua标准库列表。如果解释器不支持动态链接，就必须连同新库一起从新编译Lua语言。除了重新编译，还需要以某种方式告诉独立解释器，它应该在打开一个新的状态时打开这个库。一个简单的做法是把luaopen_模块名 添加到由luaL_openlibs打开的标准库列表中，这个列表位于文件linit.c中。我们看到linit.c的代码很少，直接贴出来：static const luaL_Reg loadedlibs[] = {   {"_G", luaopen_base},   {LUA_LOADLIBNAME, luaopen_package},   {LUA_COLIBNAME, luaopen_coroutine},   {LUA_TABLIBNAME, luaopen_table},   {LUA_IOLIBNAME, luaopen_io},   {LUA_OSLIBNAME, luaopen_os},   {LUA_STRLIBNAME, luaopen_string},   {LUA_MATHLIBNAME, luaopen_math},   {LUA_UTF8LIBNAME, luaopen_utf8},   {LUA_DBLIBNAME, luaopen_debug}, #if defined(LUA_COMPAT_BITLIB)   {LUA_BITLIBNAME, luaopen_bit32}, #endif   {NULL, NULL} };     LUALIB_API void luaL_openlibs (lua_State *L) {   const luaL_Reg *lib;   /* "require" functions from 'loadedlibs' and set results to global table */   for (lib = loadedlibs; lib->func; lib++) {     luaL_requiref(L, lib->name, lib->func, 1);     lua_pop(L, 1);  /* remove lib */   } }它的实现是将将一些标准库的加载函数的返回值通过luaL_requiref（同lua脚本中的require）保存到package.loaded中。这样lua中require时能直接得到缓存的返回值了。这里的返回值是公开的表结构。方式三：使用luaL_requiref从方式二中我们已经知道可以使用luaL_requiref将模块添加到package.loaded中。那么我们可以不用那么麻烦去修改lua的c api了。我们可以直接使用luaL_requiref方法来达到此目的。举个例子：luaL_requiref(mL, "_mylib", luaopen__mylib, 1); lua_pop(mL, 1);我们在C方法的某个初始化阶段调用一下上面的方法，把自己定义的lua c function通过table注册到package.loaded里面，让lua能直接使用。C代码中注册lua c function，用到了luaL_Reg结构，它的结构如下，包含字符串类型的name和一个lua_CFunction。typedef struct luaL_Reg {   const char *name;   lua_CFunction func;. } luaL_Reg;方式四：保存到全局表我们再回顾一下cjson的luaopen_cjson加载函数的实现：int luaopen_cjson(lua_State *l) {     lua_cjson_new(l);   #ifdef ENABLE_CJSON_GLOBAL     /* Register a global "cjson" table. */     lua_pushvalue(l, -1);     lua_setglobal(l, CJSON_MODNAME); #endif       /* Return cjson table */     return 1; }我们看到有个ENABLE_CJSON_GLOBAL宏定义，在这个宏里面它先通过lua_pushvalue将位置-1（即栈顶）的值复制了一份并压栈，然后通过lua_setglobal从栈顶pop出那个复制的表然后设置到全局表中（即_G中）。我们从上面的讲解中知道_G会赋值给Lua匿名函数的上值_ENV中，所有对全局变量的访问会访问到_ENV，所以Lua就可以直接通过键值CJSON_MODNAME访问到刚刚push到全局表的那个表了。在Lua5.1版本也可以使用luaL_register，按照官方对该方法的描述，如果带了libname参数，那么会在全局表和package.loaded里面注册那些方法。 2.5.1.2、子模块Lua脚本也是支持具有层次结构的模块名的，例如当我们 require “a.b”时，lua会自动将点符号自动转化为操作系统的分隔符，这里之前package.path的模版会被替换为以下的路径搜索列表：模版：./?.lua;/usr/local/lua/?.lua;/usr/local/lua/?/init.lua搜索列表：./a/b.lua/usr/local/lua/a/b.lua/usr/local/lua/a/b/init.luaC 子模块：举个例子，我们require C层的a.b.c，会写成 require “a.b.c”，搜索器会搜索文件a（例如a.so）,然后Lua会在该库中搜索对应的加载函数luaopen_a_b_c。2.5.1.3、模块的不同版本我们可以为每个so的不同版本命令不同so，例如我们把cjson的so改名为cjson-v5.so，然后require时可以用这个带版本的so的名字来查找so文件，不过会用不带版本号的luaopen_cjson来查找加载函数。所以我们可以通过这种方式来发布cjson的不同版本的so库了。上面方式一加载动态库so文件的代码修改后示例如下：local cjson = require "cjson-v5"   local json_str = [[{"a":"hello lua lib decode!"}]] local decode_ret = cjson.decode(json_str) print(decode_ret.a)   --output --[[     hello lua lib decode! ]]2.5.1.4、卸载模块参考这篇链接，我们无法简单的卸载一个C模块。不过我们可以简单的卸载一个lua模块。我们知道lua模块的加载函数结果保存在package.loaded中，我们可以显示的将package.loaded[模块名] = nil的方式来实现卸载。这样在下一次require这个模块时会重新查找和执行该模块的加载函数了，并将新的返回值保存在package.loaded中。 2.5.2、元机制通常，Lua语言中的每种类型的值都有一套可预见的操作集合。例如，我们可以将数字相加，可以连接字符串，还可以在表中插入键值对等。但是，我们无法将两个表相加，无法对函数作比较，除非使用元表。元表可以修改一个值在面对一个未知操作时的行为，例如，假设a和b都是表，那么可以通过元表定义来实现如何计算表达式 a + b。Lua中识别到试图将两个表相加时，它会检查两者之一是否有元表（metatable），且该元表中是否有_add字段。如果Lua语言找到了该字段，就调用该字段对应的值，即所谓的元方法（metamethod），用于计算表的和。注意：lua 脚本中的setmetatable只能给表设置元表，如果需要改变其他类型的元表只能在C语言中实现下面就以两个表相加写一个代码示例，两个表相加时我们想把他们两个集合合并在一起：local tb1 = {1,2,3} local tb2 = {'a','b','c'}   local mt = {     __add = function(a, b)         local result = {}         for _index, value in ipairs(a) do             table.insert(result, value)         end           if type(b) == "table" then             for _index, value in ipairs(b) do                 table.insert(result, value)             end         else             table.insert(result, b)         end                  return result     end } setmetatable(tb1, mt) setmetatable(tb2, mt)   local b = tb1 + tb2 for _ind, val in ipairs(b) do     print("index:" .. _ind .. ", value:" .. tostring(val)) end   --output --[[ index:1, value:1 index:2, value:2 index:3, value:3 index:4, value:a index:5, value:b index:6, value:c ]]同样的上面的实现也满足一个表和一个数值相加：local result2 = tb1 + 111 for _ind, val in ipairs(result2) do     print("index:" .. _ind .. ", value:" .. tostring(val)) end   --output --[[ index:1, value:1 index:2, value:2 index:3, value:3 index:4, value:111 ]]Lua预置了一些元方法定义，包括：算术运算元方法：__add, __div(除法), __mod(取模)等关系运算相关的元方法：__eq(等于)，__lt(小于), __le(小于等于)库定义相关的元方法：__tostring, __metatable(保护元表)等Lua语言会按照如下的步骤来查找元方法：如果第一个值有元表且元表中存在所需的元方法，那么Lua语言就使用这个元方法，与第二个值无关（如上面的代码示例）；如果第二个值有元表且元表中存在所需的元方法，Lua语言就使用这个元方法；否则Lua语言就抛出异常。接下来我们介绍一下_metatable元方法，它是用于保护元表。假设想要保护我们的集合，就要使用户既不能看到也不能修改集合的元表。如果在元表中设置__metatable字段，那么getmetatable会返回这个字段的值，而setmetatable则会引发一个错误，我们继续举一个例子：local protected_tbl = {}   mt = {     __metatable = "it's protected table" }   setmetatable(protected_tbl, mt)   -- modify metatable setmetatable(protected_tbl, {})   --output --[[     lua: meta_methods_test.lua:66: cannot change a protected metatable stack traceback:     [C]: in function 'setmetatable'     meta_methods_test.lua:66: in main chunk     [C]: in ? ]]2.5.2.1、元表的关键字__index和__newindexlua中当访问一个表中不存在的字段时会返回nil。这是正确的，但不是完整的真相。实际上，这些访问会引发解释器查找一个名为__index的元方法。如果没有这个元方法，那么像一般情况下一样，结果就是nil; 否则，则由这个元方法来提供最终的结果。如果我们希望在访问一个表时不调用__index元方法，那么可以使用函数rawget，调用rawget(t, i)会对表t 进行原始访问，即在不考虑元表的情况下对表进行简单的访问。元方法__newindex与__index类似，不同之处在于前者用于表的更新而后者用于表的查询。当对一个表中不存在的索引赋值时，解释器就会查找__newindex元方法。同样的它也有一个原始函数允许我们绕过元方法：rawset(t, k, v)，它等价于t[k] = v，但不涉及任何元方法。在只读表的应用：以一个例子来实践一下元表的__index和__newindex操作，熟悉一下lua中强大的元机制：local readonly_table = {     ["a"] = 1, ["b"] = 2 }   local mt = {     __index = readonly_table,     __newindex = function(t, k, v)         error("attempt to update a readonly table with key:" .. tostring(k) .. ", value:" .. tostring(v))     end }   local readonly_t = setmetatable({}, mt)   print(readonly_t["a"]) readonly_t["a"] = 123   --output --[[ 1 lua: table_readonly.lua:8: attempt to update a readonly table with key:a, value:123 stack traceback:     [C]: in function 'error'     table_readonly.lua:8: in metamethod 'newindex'     table_readonly.lua:15: in main chunk     [C]: in ?   ]]这个示例中readonly_t本身是一张空表，这样对空表的取值和赋值操作都不会找到对应的键值key，那么必然会走到元表的__index和__newindex，而我们在示例中对__index放开了，存放了一些数据，这样readonly_t就可以读取到数据里面的值。但是当我们想要修改readonly_t的值时，也只会触发到__newindex，而这里我们会直接返回一个错误。从示例的执行结果看出达到了这个目的。我们看到readonly_t[“a”]能正确返回1，而readonly_t[“a”] = 123会提示错误 2.5.2.2、userdata类型设置元表Lua里面userdata类型表示的是一个C指针。我们以一个示例演示如何在Lua中使用C代码中的一个结构体，要知道Lua中没有结构体这样的直接对应的数值类型，但是有userdata，可以表示任意一块C的内存空间，要操作这样一个内存空间，Lua提供了一种方法可以为一个数值设置元表，然后我们在元表中可以定义方法来操作这个内存空间了。先了解几个关键的方法：void lua_setmetatable (lua_State *L, int index);这个方法是从栈顶弹出一个table类型的数值，然后把它设置为指定index索引位置的数值作为它的元表。我们前面介绍过Lua数据栈里面的存放的都是TValue类型的结构，这个TValue实际是一个union类型，里面表示了Lua里面所有基本类型。所以也就是说lua_setmetatable可以为任意的Lua数值类型设置一个元表。在元表中我们可以定义_index键值，这里示例中是一个table（示例代码参考的这篇文章）。// foo.c   #include <lua.h> #include <lauxlib.h> #include <lualib.h> #include <limits.h>   #define BITS_PER_WORD (CHAR_BIT * sizeof(int)) #define I_WORD(i)     ((unsigned int)(i))/BITS_PER_WORD #define I_BIT(i)      (1 << ((unsigned int)(i)%BITS_PER_WORD))   typedef struct NumArray {     int size;     unsigned int values[1]; } NumArray;   int newArray(lua_State* L) {     int i, n;       n = luaL_checkint(L,1);       luaL_argcheck(L, n >= 1, 1, "invalid size.");       size_t nbytes = sizeof(NumArray) + I_WORD(n - 1) * sizeof(int);       NumArray* a = (NumArray*) lua_newuserdata(L,nbytes);       a->size = n;       for (i = 0; i < I_WORD(n - 1); ++i)         a->values[i] = 0;       luaL_getmetatable(L, "myarray");       lua_setmetatable(L, -2);       return 1; }   int setArray(lua_State* L) {     //1. Lua传给该函数的第一个参数必须是userdata，该对象的元表也必须是注册表中和myarray关联的table。     //否则该函数报错并终止程序。     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");     int index = luaL_checkint(L,2) - 1;       luaL_checkany(L,3);     // there are 3 arguments     luaL_argcheck(L,a != NULL,1,"'array' expected.");     luaL_argcheck(L,0 <= index && index < a->size,2,"index out of range.");       if (lua_toboolean(L,3))         a->values[I_WORD(index)] |= I_BIT(index);     else         a->values[I_WORD(index)] &= ~I_BIT(index);       return 0; }   int getArray(lua_State* L) {     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");     int index = luaL_checkint(L,2) - 1;     luaL_argcheck(L, a != NULL, 1, "'array' expected.");     luaL_argcheck(L, 0 <= index && index < a->size,2,"index out of range");     lua_pushboolean(L,a->values[I_WORD(index)] & I_BIT(index));     return 1; }   int getSize(lua_State* L) {     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");     luaL_argcheck(L,a != NULL,1,"'array' expected.");     lua_pushinteger(L,a->size);     return 1; }   int array2string(lua_State* L) {     NumArray* a = (NumArray*)luaL_checkudata(L,1,"myarray");     lua_pushfstring(L,"array(%d)",a->size);     return 1; }   static luaL_Reg arraylib_f [] = {     {"new", newArray},     {NULL, NULL} };   static luaL_Reg arraylib_m [] = {     {"set", setArray},     {"get", getArray},     {"size", getSize},     {"__tostring", array2string}, //print(a)时Lua会调用该元方法。     {NULL, NULL} };   int luaopen_foo(lua_State* L) {     //1. 创建元表，并将该元表指定给newArray函数新创建的userdata。在Lua中userdata也是以table的身份表现的。     //这样在调用对象函数时，可以通过验证其metatable的名称来确定参数userdata是否合法。     luaL_newmetatable(L,"myarray");     lua_pushvalue(L,-1);       //2. 为了实现面对对象的调用方式，需要将元表的__index字段指向自身，同时再将arraylib_m数组中的函数注册到     //元表中，之后基于这些注册函数的调用就可以以面向对象的形式调用了。     //lua_setfield在执行后会将栈顶的table弹出。     lua_setfield(L, -2, "__index");       //将这些成员函数注册给元表，以保证Lua在寻找方法时可以定位。NULL参数表示将用栈顶的table代替第二个参数。     luaL_register(L, NULL, arraylib_m);       //这里只注册的工厂方法。     luaL_register(L,"testuserdata",arraylib_f);       return 1; }luaL_checkudata用于校验userdata是否是我们预想的类型。Lua中通过为userdata绑定一个元表，然后通过C方法检查userdata是否有指定的元表的方式来实现的。lua中使用require "foo"   local array = testuserdata.new(100)   print(array:size())     -- 100   for i=1,100 do     array:set(i, i%5 == 0) end   for i=1,100 do     print(array:get(i)) end下面解释一下这个代码：require “foo”，会走Lua的模块加载机制（前面介绍了），找到foo动态库，然后执行luaopen_foo加载函数。c 中 luaopen_foo函数调用luaL_register(L,”testuserdata”,arraylib_f);在全局表中注册了testuserdata键值，以及和它对应的lua c function列表lua 中 testuserdata. new(100) 中testuserdata在lua转换成字节码时被识别为一个全局变量（前面介绍过）。所以会自动添加前缀，结果为_ENV.testuserdata.new(100)。我们现在知道了_ENV对应全局表中的_G。那么这段代码实际的意思是会到全局表中查找testuserdata关键字，那么此时的new方法就是C里面的newArray方法了newArray方法会构建一个NumArray结构体，并绑定元表myarraylua代码中接下来array:size()方法调用又是怎么样呢？“:”符号的方式和 “.” 使用方式不同, 它转化为”.”的方式会变为array.size(array), 也就是它的第一个参数为调用的table它自己。那么这段代码的意思是调用array这个userdata类型数值的 size方法，该方法会在元表中_index中查找于是找到了键值size对应的之前注册的getSize 这个 lua c function。getSize C function中首先会在栈顶找到userdata它自己（前面介绍的array.size(array)），然后转换为 NumArray 指针赋值给变量a。对应的代码是 —— NumArray* a = (NumArray*)luaL_checkudata(L,1,”myarray”);最后从该结构实例中取出size成员，并把该结果压栈返回给lua。return 1 是告诉Lua栈里面留了一个值给它，lua中调用返回后可以直接赋值给Lua变量。注意：Lua调用C时会在Lua虚拟机的数据栈中分配一块新的范围作为它们之间交互的栈空间。调用到C时栈里面的索引从1开始依次存放了Lua调用时传递过来的参数，c function中可以直接从栈中pop出对应的参数使用。 2.5.2.3、继承Lua中的table和元机制的确很强大。它们结合在一起可以实现其它语言中的继承的行为。不过它的继承和Java语言的继承不同，它和javascript类似，是基于原型的。简单说就是只有对象,没有类;对象继承对象,而不是类继承类。“原型对象”是基于原型语言的核心概念。原型对象是新对象的模板，它将自身的属性共享给新对象。一个对象不但可以享有自己创建时和运行时定义的属性，而且可以享有原型对象的属性。写一个Lua中继承的典型的例子：local Account Account = { }   function Account:get_name()     print("return name: " .. tostring(self.name)) end   function Account:new(o)     o = o or {}     self.__index = self     setmetatable(o, self)     return o end   local obj1 = Account:new({name = "Tom"}) local obj2 = Account:new({name = "Jerry"}) obj1:get_name() obj2:get_name() --output --[[ return name: Tom return name: Jerry ]]这个示例中定义了一个table Account作为父对象，里面定义了一个公共方法get_name，用于打印name属性。然后在Account里面定义了new方法，这个方法里面给传进来的table实例（子对象）设置一个元表（元表就是Account自己），这个元表的__index也设置为Account自己，这样在子对象调用get_name时（obj1:get_name()和obj2:get_name()）会访问到父对象的方法了。这个示例展示了继承的一个特性——多个对象共享行为。作为一个“类”，除了多对象共享行为，它还需要具备其它的特点，这里总结为3个：多个对象共享行为继承私有性Lua是基于原型的继承，可以实现对象继承对象，代码示例如下：-- 基于原型的继承，对象继承对象 local TomClass = Account:new({name = "Tom"})   function TomClass:get_name()     print("Tom say his full name is :" .. tostring(self.name)) end   local tom = TomClass:new({name = "Tomcat"}) tom:get_name()   --output --[[     Tom say his full name is :Tomcat ]]上面这个示例中，基于Account我们构建了TomClass实例, 然后tom实例是基于TomClass。我们看到在这个示例中TomClass实例复写了Account的get_name方法，并修改了print打印的内容，当我们使用TomClass new一个新的实例时此时调用get_name方法不再使用Account中的get_name，而是找到了TomClass里面的get_name了。2.5.2.3.1、多重继承再来看Lua中一个多重继承的示例：local function search(k, plist)  for i=1, #plist do     local v = plist[i][k]     if v then return v end end end   function createClass(...)     local c = {}     local parents = {...}       setmetatable(c, {__index = function(t, k)         return search(k, parents)     end})       -- c 做为其实例的元表     c.__index = c       function c:new(o)         o = o or {}         setmetatable(o, c)         return o     end       return c end   local Account = {} function Account:get_account()     return self.account end   function Account:set_account(account)     self.account = account end   local Named = {} function Named:get_name()     return self.name end   function Named:set_name(name)     self.name = name end   local NamedAccount = createClass(Account, Named) local account = NamedAccount:new({name='Tom', account='tom123'}) print("account name:" .. account:get_name() .. ", account:" .. account:get_account())   --output --[[     account name:Tom, account:tom123 ]]在这个示例中我们定义了两个table——Account, Named，用于多重继承的2个“父类”，它们分别提供了方法操作各自的属性account和name。提供了一个createClass方法，这个方法返回一个table，它包含这些父类的列表，同时它提供了new方法用于构建新的子对象。子对象设置该table为它的元表，并指定__index也为这个table，让子对象和多个父对象关联起来。这个table也设置了一个元方法，它的__index我们设置了一个function，这个函数会调用search方法在父类列表中（parents）查找对应的方法名。通过这种方式实现了多重继承的目的。我们看到子对象account在使用方法get_name和get_account时分别使用到父对象的方法来执行的。 2.5.2.3.2、私有性继承中另一个重要的特性是私有性。总结起来有以下3种方式来保证私有性：在一个table返回时只返回需要公开的方法或字段。可以是两个table的方式，一个table放对象状态，一个table放操作；也可以是返回一个方法（单方法对象）。继承出来的table它的元表不实现__newindex，则自己的属性修改不会影响到公共的父类，实现了私有性对于共享的数据，可以用对偶表示法实现私有性，即用对象唯一地址来存储数据，只有持有该对象才能访问对应的数据示例一：返回公开方法和字段，屏蔽私有字段的方式：function newAccount(initName, initage)     local _self = {name = initName, age = initage}       local print_name = function()         print("my name is :" .. tostring(_self.name))     end       local add_age = function()         _self.age = _self.age + 1         print("now my age is:" .. tostring(_self.age))     end       return {         printName = print_name,         addAge = add_age     } end   local account = newAccount("Tom", 18) account.printName() account.addAge()   --output --[[ my name is :Tom now my age is:19 ]]上面示例中newAccount方法返回了一个新的对象，它公开了两个方法：printName和addAge，这个新的对象绑定了一个上值（upvalue）_self，它也是一个table，里面放了2个属性——name和age，外部在使用这个对象时只能通过公开的方法来操作这个私有table（_self）的值。这样有效的保证了_self的私有性。示例二：对偶表示法local my_companys = {}   local Account = {      }   function Account:new(o, company)     o = o or {}     self.__index = self     setmetatable(o, self)     my_companys[o] = company       return o end   function Account:print()     print("my name is:" .. tostring(self.name) .. ", company:" .. tostring(my_companys[self])) end   local a1 = Account:new({name = "Tom"}, "alibaba") local a2 = Account:new({name = "Jerry"}, "Tencent")   a1:print() a2:print()   --output --[[ my name is:Tom, company:alibaba my name is:Jerry, company:Tencent ]]对偶表示法将对象私有属性值保存在以该对象为键值的一张表中统一管理。后续需要访问这些私有属性时必须持有相应的对象才能访问。这样有效的保证了私有性。2.5.3、lua中的错误处理机制由于Lua是一门可扩展的嵌入型的脚本语言，所有的Lua操作起源于宿主的C代码，通过lua_pcall来调用的，任何的Lua执行错误都会返回到C层，我们可以在这一层做一些错误的处理。下面会介绍一种全局捕获Lua异常的做法。lua中关于错误的处理有以下的方法：产生一个错误：Lua脚本中使用error，在C层可以用lua_error，也有一个辅助库的luaL_error（可以打印格式化的字符串）assert(v [, message])： 断言，如果v是false(前面提到在lua里面，false和nil都认为是false)就会产生一个错误。不然的话就会返回v的所有返回信息。message是出错时的错误信息，如果没有，则默认为“assertion failed”pcall和xpcall:  pcall (f, arg1, ···)和xpcall (f, err)。都是在保护模式下执行function。这意味着如果f中执行有异常pcall会抓住这个异常然后返回错误信息。xpcall和pcall的差异在于xpcall可以带一个err handler function。如果f中有异常，xpcall能捕获异常，并把错误信息传给err function来处理lua_atpanic: 如果应用调用了Lua API中的函数，就可能发生错误。Lua语言通常通过长跳转来提示错误，但是如果没有相应的setjmp, 解释器就无法进行长跳转。此时，API中的任何错误都会导致Lua调用紧急函数（panic function），当这个函数返回后，应用就会退出。我们可以通过函数lua_atpanic来设置自己的紧急函数，但作用不大。可以用做统计收集错误信息。debug.traceback, LuaL_traceback: 会返回一个崩溃时调用栈的字符串类型信息。luaL_argerror, luaL_check*，luaL_typeerror, luaL_typeerror: 这些方法也是用于抛出一个错误，不过是关于参数或类型检查的。 2.5.3.1、C语言的setjmp机制C语言没有C++或Java的异常机制，但可以通过setjmp/longjmp实现类似的效果，Lua的pcall就是利用的setjmp来实现异常捕获的。举个C代码实现的例子：#include <stdio.h> #include <stdlib.h> #include <setjmp.h>   jmp_buf env;   int my_func(int a, int b) {     if (b == 0) {         printf("do not allow division by 0\n");         longjmp(env, 1);     }     return a / b; }   int main(int argc, char const *argv[]) {     int res = setjmp(env);     if (res == 0) {         printf("return from setjmp\n");         my_func(10, 0);     } else {         printf("return from longjmp: %d\n", res);     }     return 0; }输出结果为：return from setjmp do not allow division by 0 return from longjmp: 1代码执行流程如下：使用setjmp保存当前执行环境到jmp_buf，然后默认返回0。程序继续执行，到某个地方调用longjmp，传入上面保存的jmp_buf，以及另一个值。此时执行点又回到调用setjmp的返回处，且返回值变成longjmp设置的值。在Lua中使用pcall时也是同样的效果，任意在pcall中的异常最终会通过longjmp跳转到之前调用pcall的位置，然后带上出错的信息。我们代码可以在pcall返回时判断执行的结果来处理异常时的逻辑。 2.5.3.2、Lua中的全局错误捕获有了上面的知识作为铺垫我们不难实现Lua脚本中的全局错误捕获了。我们知道所有的Lua操作起源于宿主的C代码，所以如果要全局捕获lua脚本的异常当然要在C层来处理了。开始着手前我们再自己看下C层的lua_pcall 函数定义（链接）：int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);我们重点看下第四个参数errfunc，这个值是个整形值它代表错误处理函数在数据栈中的位置。我们可以利用这个错误处理函数来接收pcall返回的错误信息。下面是一个Android里面通过JNI调用到C层，然后调用Lua API的lua_pcall来执行Lua二进制chunk字节码，并捕获异常的代码。Java_com_conio_mysdk_nativeDoBuffer(JNIEnv *env, jclass _type, jlong luaState, jbyteArray buff , jlong sz , jstring n) {     lua_State* L = (lua_State*)luaState;       lua_pushcfunction(L, msghandler);     jbyte * cBuff = ( *env )->GetByteArrayElements( env , buff, NULL );     const char * name = ( * env )->GetStringUTFChars( env , n , NULL );     int status = luaL_loadbuffer( L , ( const char * ) cBuff, ( int ) sz, name );     if (status == 0) {         status = lua_pcall(L, 0, LUA_MULTRET, 1);     }       const char* ret = "";       if (status != 0) {         ret = lua_tostring(L, -1);     }     lua_settop(L, 0);     ( *env )->ReleaseStringUTFChars( env , n , name );       ( *env )->ReleaseByteArrayElements( env , buff , cBuff , 0 );     return (*env)->NewStringUTF(env, ret); }上面的代码中lua_pcall的第四个参数我们传了1，代表数据栈中索引1的位置我们放了一个错误处理函数。这个函数就是通过lua_pushcfunction push到栈中的，代码中push了一个msghandler的lua c function。我们在看下msghandler的实现：static int msghandler (lua_State *L) {   onLuaError(L);   const char *msg = lua_tostring(L, 1);   if (msg == NULL) {  /* is error object not a string? */     if (luaL_callmeta(L, 1, "__tostring") &&  /* does it have a metamethod */         lua_type(L, -1) == LUA_TSTRING)  /* that produces a string? */       return 1;  /* that is the message */     else       msg = lua_pushfstring(L, "(error object is a %s value)",                                luaL_typename(L, 1));   }   luaL_traceback(L, L, msg, 1);  /* append a standard traceback */   return 1;  /* return the traceback */ }这段代码捕获了pcall中的异常信息，它位于栈索引1的位置，不过这个异常信息不一定是字符串类型，如果不是我们尝试从它的元表中调用__tostring方法来获得错误信息。拿到错误信息我们把它通过luaL_traceback拼接到栈回溯信息前，并通过return 1将结果返回。这个地方我们可以把这些错误信息通过自己的异常上传逻辑收集起来，从而实现了全局Lua异常捕获、收集和上传了。 2.5.4、引用机制一些情况下C函数需要保存一些非局部数据，即生存时间超出C函数执行时间的数据。在C语言中，我们通常使用全局变量（extern）或静态变量来满足这种需求。然而，当我们为Lua编写库函数时，这并不是一个好办法。首先，我们无法在一个C语言变量中保存普通的Lua值。其次，使用这类变量的库无法用于多个Lua状态。Lua的CAPI提供了两个类似的地方来存储非局部数据，即注册表（registry）和上值（upvalue）。然而注册表是一个普通的Lua表，它的键很有可能冲突。引用机制主要是解决在Lua中拓展多个C库时可能会在全局表中定义相同的key，带来潜在的问题。这个机制简单说引用机制就是Lua自动管理key，开发者不应该手动指定key，否则就可能破坏内部的Key重用机制。引用机制提供了两个方法：int luaL_ref (lua_State *L, int t) void luaL_unref (lua_State *L, int t, int ref)luaL_ref会从栈中弹出一个值，然后分配一个新的整形的键，使用这个键将从栈中弹出的值保存到注册表中，最后返回该整形键，而这个键就被称为引用（reference）。最后想要释放值和引用，我们可以调用 luaL_unref。 2.5.5、垃圾回收机制云风大神有一篇关于Lua垃圾回收机制的讲解，非常深入，详细了解可以参考这篇文章——链接。这里简单介绍一下Lua的垃圾收集器。一直到Lua 5.0，Lua语言使用的都是一个简单的标记-清除（mark-and-sweep）式垃圾收集器。这种收集器又被称为“stop-the-world”（全局暂停）式的收集器，意味着Lua语言会时不时的停止主程序的运行来执行一次完整的垃圾收集周期。每一个垃圾收集周期由四个阶段组成：标记（mark）、清理（cleaning）、清除（sweep）和析构（finalization）。标记阶段会把根结点集合标记为活跃，根节点就是由Lua语言可以直接访问的对象组成。在Lua语言中，这个集合只包括C注册表（主线程和全局环境都是在这个注册表中预定义的元素）。Lua5.1使用了增量式垃圾收集器。这种垃圾收集起像老版的垃圾收集器一样执行相同的步骤，但是不需要在垃圾收集期间停止主程序的运行。相反，它与解释器一起交替运行。每当解释器分配了一定数量的内存时，垃圾收集器也执行一小步（这意味着，在垃圾收集器工作期间，解释器可能会改变一个对象的可达性。为了保证垃圾收集器的正确性，垃圾收集器中的有些操作具有发现危险改动和纠正所涉及的对象标记的内存屏障）。Lua 5.2引入了紧急垃圾收集。当内存分配失败时，Lua语言会强制进行一次完整的垃圾收集，然后再次尝试分配。 2.5.5.1、一些辅助垃圾回收机制的工具2.5.5.1.1、弱引用表所谓弱引用（weak reference）是一种不在垃圾收集器考虑范围内的对象引用。如果对一个对象的所有引用都是弱引用，那么垃圾收集器将会回收这个对象并删除这些弱引用。一个表是否为弱引用表是由其元表中的__mode字段所决定的。当这个字段存在时，其值应为一个字符串：如果这个字符串为“v”，那么代表这个表的值是弱引用的；如果这个字符串是“kv”，那么这个表的键和值都是弱引用的。举个栗子：a = {} mt = {__mode = "k"} setmetatable(a, mt) --现在'a'的键是弱引用的了 key = {} -- 创建第一个键 a[key] = 1 key = {} -- 创建第二个键 a[key] = 2   collectgarbage() --强制进行垃圾回收 for k, v in pairs(a) do  print(v) end   --output --[[ 2 ]]上面的示例中虽然我们在table a 中创建了两个key，分别对应值1和2。但是由于设置了a的元表中的__mode的弱引用表的模式为“k”。我们看到当key被赋值2次时，第一次赋给key的值就不再被强引用了，这样在强制垃圾回收后a 表中第一个键值对就被垃圾回收器从表中移除了。谈到弱引用表，这里需要提一下“瞬表”的概念：一种棘手的情况是，一个具有弱引用键的表中的值又引用了对应的键。一个典型的示例是敞亮函数工厂。这种工厂的参数是一个对象，返回值是一个被调用时返回传入对象的函数：do     local mem = {}     setmetatable(mem, {__mode = "k"})     function factory(o)         local res = mem[o]         if not res then             res = (function() return o end)             mem[o] = res         end            return res     end end不过，这里另有玄机。请注意，表mem中与一个对象关联的值（函数）回指向了它自己的键（对象本身）。虽然表中的键是弱引用的，但是表中的值却不是弱引用的。从一个弱引用表的标准理解看，这个表里面没有任何东西会被移除。由于值不是弱引用的，所以对于每一个函数来说都存在一个强引用。每一个函数都指向其对应的对象，因而对于每一个键来说都存在一个强引用。因此，即使有弱引用的键，这些对象也不会被回收。Lua语言通过瞬表的概念来解决这个问题。在Lua语言中，一个具有弱引用键和强引用值的表是一个瞬表。在一个瞬表中，一个键的可访问性控制着对应值的可访问性。更确切的说，考虑瞬表中的一个元素（k, v），指向的v的引用只有当存在某些指向k的其他外部引用存在时才是强引用，否则即使v （直接或间接地）引用了k，垃圾收集器最终会收集k并把元素从表中移除。 2.5.5.1.2、析构器垃圾收集器不仅可以回收对象，也可以帮助程序释放资源。出于这个目的，几种编程语言都提供了析构器。析构器是一个与对象关联的函数，当该对象即将被回收时该函数会被调用。Lua 语言通过元方法__gc实现析构器，例如：o = {x = 'hi'} setmetatable(o, {__gc = function(o) print("finalize o" .. o.x) end}) o = nil   collectgarbage()    --output --[[     hi ]]在本例中，我们首先创建一个带有__gc元方法元表的表，然后把这个变量o赋值为nil，也就是抹去了与这个表的唯一联系（全局变量），再强制进行一次完整的垃圾回收。在垃圾回收期间，Lua 语言发现表已经不再是可访问的了，因此会调用表的析构函数，也就是元方法__gc。3、参考文献云风的blog: https://blog.codingnow.com/lua官方文档：https://www.lua.org/ddj.html《The feasibility of the embedded software development with Lua programming》Lua 之 userdata：https://www.cnblogs.com/chenny7/p/4077364.html《lua的函数、闭包、函数调用》《Error Handling》

方法调用在程序运行时,进行方法调用是最普遍,最频繁的操作方法调用不等于方法执行:方法调用阶段唯一的任务就是确定被调用的方法版本,即调用哪一个方法不涉及方法内部的具体运行过程Class文件的编译过程不包括传统编译中的连接步骤Class文件中的一切方法调用在Class文件里面存储的都是符号引用,而不是方法在在实际运行时内存布局中的入口地址,即之前的直接引用:这样使得Java具有更强大的动态扩展能力同时也使得Java方法调用过程变得相对复杂需要在类加载期间,甚至会到运行期间才能确定目标方法的直接引用方法解析所有方法调用中的目标方法在Class文件里都是一个常量池的引用在类的加载解析阶段,会将其中的一部分符号引用转化为直接引用:方法在程序真正执行之前就有一个可确定的调用版本,并且这个方法的调用版本在运行期是不可改变的也就是说,调用目标在程序代码中完成,编译器进行编译时就必须确定下来,这也叫做方法解析Java方法分类在Java中符合 "编译期可知,运行期不可变" 的方法有两大类:静态方法: 与类型直接关联私有方法: 在外部不可被访问这两种方法各自的特点决定这两种方法都不可能通过继承或者别的方式重写版本,因此适合在类加载阶段进行解析非虚方法: 在类加载阶段会把符号引用解析为该方法的直接引用静态方法私有方法实例构造器父类方法虚方法: 在类加载阶段不会将符号引用解析为该方法的直接引用除去以上的非虚方法,其它的方法均为虚方法静态分派public class StaticDispatch { static abstract class Human { } static class Man extends Human { } static class Woman extends Human { } public static void sayHello(Human guy) { System.out.println("Hello, Guy!"); } public static void sayHello(Man guy) { System.out.println("Hello, Gentleman!"); } public static void sayHello(woman guy) { System.out.println("Hello, Lady!"); } public static void main(String[] args) { Human man = new Man(); Human women = new Woman(); sayHello(man); sayHello(woman); } }Human man = new Human();Human为变量的静态类型Man为变量的实际类型静态类型和实际类型在程序中都会放生变化:静态类型:静态类型的变化仅仅在使用时发生变量本身的静态类型不会被改变最终的静态类型在编译器中可知实际类型:实际类型变化的结果在运行期才确定下来编译器在编译期间并不知道一个对象的实际类型是什么Human human = new Man(); sayHello(man); sayHello((Man)man); // 类型转换,静态类型变化,转型后的静态类型一定是Man man = new woman(); // 实际类型变化,实际类型是不确定的 sayHello(man); sayHello((Woman)man); // 类型转换,静态类型变化编译器在重载时是通过参数的静态类型而不是实际类型作为判断依据,静态类型在编译期间可以知道:编译阶段,Javac编译器会根据参数的静态类型决定使用哪个重载版本静态分派:所有依赖静态类型来定位方法的执行版本的分派动作典型应用 :方法重载静态分派发生在编译阶段,因此确定静态分派的的动作不是由虚拟机执行的,而是由编译器完成的由于字面量没有显示静态类型,只能通过语言上的规则去理解和推断public class LiteralTest { public static void sayHello(char arg) { System.out.println("Hello, char!"); } public static void sayHello(int arg) { System.out.println("Hello, int!"); } public static void sayHello(long arg) { System.out.println("Hello, long!"); } public static void sayHello(Character arg) { System.out.println("Hello, Character!"); } public static void main(String[] arg) { sayHello('a'); } }编译器将重载方法从上向下依次注释,得到不同的输出如果编译器无法确定要自定转型为哪种类型,会提示类型模糊,拒绝编译public class LiteralTest { public static void sayHello(String arg) { // 新增重载方法 System.out.println("Hello, String!"); } public static void sayHello(char arg) { System.out.println("Hello, char!"); } public static void sayHello(int arg) { System.out.println("Hello, int!"); } public static void sayHello(long arg) { System.out.println("Hello, long!"); } public static void sayHello(Character arg) { System.out.println("Hello, Character!"); } public static void main(String[] args) { Random r = new Random(); String s = "abc"; int i = 0; sayHello(r.nextInt() % 2 != 0 ? s : 1 ); // 编译错误 sayHello(r.nextInt() % 2 != 0 ? 'a' : false); //编译错误 } }动态分派public class DynamicDispatch { static abstract class Human { protected abstract void sayHello(); } static class Man extends Human { @override protected void sayHello() { System.out.println("Man Say Hello!"); } } static class Woman extends Human { @override protected void sayHello() { System.out.println("Woman Say Hello!"); } } public static void main(String[] args) { Human man = new Man(); Human women = new Woman(); man.sayHello(); woman.sayHello(); man = new Woman(); man.sayHello(); } }这里不是根据静态类型决定的静态类型的Human两个变量man和woman在调用sayHello() 方法时执行了不同的行为变量man在两次调用中执行了不同的方法导致这个现象的额原因 :这两个变量的实际类型不同Java虚拟机是如何根据实际类型分派方法的执行版本的: 从invokevirtual指令的多态查找过程开始 ,invokevirtual指令运行时解析过程大致分为以下几个步骤:找到操作数栈顶的第一个元素所指向的对象的实际类型,记作C如果在类型C中找到与常量中的描述符和简单名称相符合的方法,然后进行访问权限验证,如果验证通过则返回这个方法的直接引用,查找过程结束;如果验证不通过,则抛出java.lang.illegalAccessError异常如果未找到,就按照继承关系从下往上依次对类型C的各个父类进行第二步的搜索和验证过程如果始终没有找到合适的方法,则抛出java.lang.AbstractMethodError异常Java语言方法重写的本质:invokevirtual指令执行的第一步就是在运行时期确定接收者的实际类型,所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上这种在运行时期根据实际类型确定方法执行版本的分派过程就叫做动态分派虚拟机动态分派的实现虚拟机概念解析的模式就是静态分派和动态分派,可以理解虚拟机在分派中 "会做什么" 这个问题虚拟机 "具体是如何做到的" 在各种虚拟机实现上会有差别:由于动态分派是非常频繁的动作,而且动态分派的方法版本选择过程需要运行时在类的方法元数据中搜索合适的目标方法因此在虚拟机的实际实现中,为了基于性能的考虑,大部分实现都不会真正的进行如此频繁的搜索最常用的"稳定优化"的方式是为类在方法区中建立一个虚方法表(Virtual Method Table,即vtable), 使用虚方法表索引代替元数据查找以提高性能虚方法表中存放着各个方法的实际入口地址:如果某个方法在子类中没有被重写,那子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的,都指向父类的实际入口如果子类中重写了这个方法,子类方法表中的地址将会替换为指向子类实际方法的入口地址具有相同签名的方法,在父类,子类的虚方法表中具有一样的索引序号:这样当类型变换时,仅仅需要变更查找的方法表,就可以从不同的虚方法表中按索引转换出所需要的入口地址方法表一般在类加载阶段的连接阶段进行初始化:准备了类的变量初始值后,虚拟机会把该类的方法表也初始化完毕

李磊博士在 ACL 2016 现场，右侧是本篇论文一、关于 ACL2016 收录的论文/机器之心：首先能否介绍一下这篇论文吗？包括研究背景，研发方法，以及核心的 CFO 模型等。李磊：这项工作是我当时在美国百度深度学习研究院时开展的，当时 CMU 的实习生戴自航，百度 IDL 同事徐伟，和我一起合作，来了头条之后这项研究继续进行 。首先，我们研究的问题是要解决知识类问答，比如说「美国总统是谁」、「哈利波特是谁写的」，它有别于更加开放和困难的通用问答。我们做的是整个问答系统中的知识类。知识类的背后有个知识库，我们用的是谷歌做的Freebase，解决的英文问题，但同样的技术也适用于其他语言的知识库上，只要有生成好的知识数据。知识库里的信息表达成三元组形式，比如说有哈利波特、J.K.罗琳，以及两者之间的「作者关系」。但我们系统回答的问题实际上不是这种三元组形式（直接提三元组形式的问题比较简单），而是一个自然语言问题，比如说「Who wrote harry potter ?」。知识在知识库里表达成三元组形式的结构化信息，系统要做的事情是问了这个自然语言问题后，从知识库里找出这样的答案。这个问题的难度在于，1）知识库非常大，经过筛选后还有 500 万实体信息、 7,500 组关系和 筛选之后的 2,200 万三元组事实信息（筛选之前是 19 亿事实）。因此，从这些海量数据中找出答案是非常困难的。2）除了知识库很大之后，自然语言的问题本身也比较复杂，因为有多种问法和表达方式。即使同一个问题，对于同一个实体和关系，也会有不同表示，同一个名字也会指向不同实体。比如说「哥伦布因什么而闻名？」这个主题有可能指发现新大陆的哥伦布，也有可能是俄亥俄州的哥伦布市，甚至是其他实体。3）而我们的训练数据是有限的，只有 10 万个标注数据（注：Facebook做的数据集），包括问题和答案，我们用了其中的 7 万来做训练，剩下的 来做验证和测试。我们用的方法是深度学习方法加上知识库，我们的方法分为几步，首先，我们观察到，需要把自然语言问题表达成结构化 query ，这种query形式比较接近数据库里的SQL，也是选择一个什么样的 object 满足什么样的条件，我们需要把这个结构化 query 里的条件信息从问题里找出来，比如说 Harry Potter 对应知识库里的哪个实体（subject），我们需要把这个问句里的关系（relation）找出来，有了这两个之后，就能做一个结构化的查询语句，然后从知识库里找出答案。举个例子，比如说「What theme is the book that amies of memory ？」，传统的做法是，为了找到实体，需要把这句话里所有的词都当成可能出现实体的集合，比如说 the book 是一个实体，theme、memory 等。但我们真正要找的实体是 amies of memory ，而且要知道这指的是那本书。如果按照传统方法，会出现很多噪音。而我们的方法是通过神经网络，用了一个Stacked Bidirectional GRU ，它是一个上下叠加起来的多层双向循环神经网络，我们通过这个模型去计算出问题中的实体以及实体之间的关系，之后就是构建结构化的查询语句以及从知识库里寻找答案。此外，在测试结果上，我们的准确率超过了微软和 Facebook。（见下图）机器之心：这次提出的 CFO 方法会考虑上下文的语境理解吗？李磊：现在还没有用上下文信息，问题之间都是独立的。机器之心：在整个模型的几个部分中，比如说 relation network 、subject network，词向量是共享的吗？李磊：并没有共享，但也可以做成共享的。另外，我们也基于额外训练好的词向量做了实验，发现效果差不多。机器之心：在 relation network 中, 对问题用双向 GRU 建模的时候，在测试阶段是不是可能出现了词汇表以外的 unknown words（文章中提到有） 出现了之后，是怎么处理这些词的，随机初始一个相应维度的 embedding 吗？ 李磊：对 unknown words 我们是用了传统方法，特殊标记。机器之心：注意到整个模型的不同部分之间的关联性，应该是比较拟合数据集的。最终选择的从 subject-relation 构建的查询，应该几乎都可以从知识库中找到答案（不论正确与否），是这样吗？李磊：如果这个问题的答案没有在这个知识库的话，是没有办法找到答案。但我们不需要知识库里的每个知识点都有人提过问题，比如说我问过「哈利波特是谁写的」这个问题，但从来没有遇到过「冰与火之歌是谁写的」这个问题，但它依然知道冰与火之歌是本书，而且知道要找的是两者的关系。机器之心：把联合概率的求解近似为分步计算确实是极大提高了计算的效率。那么，更高层地，有没有考虑在 single-fact question 的基础上，做一些多轮的推理工作？ 从某种意义上来说，都是一种链式优化的过程。李磊：多轮推理我们已经做了，我们现在也基于 CFO 的方法做了多轮推理，但论文还没发表。机器之心：这项研究是在哪个平台上完成的？李磊：模型和运算用的是 Torch ，整个问答系统是 Python 加 Torch，再加存储查询三元组知识库的 Virtuoso 系统。机器之心：论文中的方法其实是用神经网络等方法改进了传统问答系统 pipeline 的查询语句的 suject 和 relation 的选择。有没有考虑过用生成式模型自动来构建类似于 SPARQL 语句？  目前为止，端对端的模型是否还是比较难以在这种场合下应用？李磊：我们现在已经是生成式模型，生成了一个 SPARQL Query，只不过这个 SPARQL 是非常结构化的，实际上这是一个模板，我们只需要把模板中空的地方填进去就行了，而这些空的地方是通过我们的模型从问题里找出来的。端对端还是有必要的，如果以后要处理通用问题，有些问题会有非常复杂的 SPARQL 问法，需要非常复杂的 SPARQL 语句才能问出来，在这种情况下就需要生成了，这也是非常难的。现在流行的端对端训练的确可以优化整个流程里面的所有参数，同时获得新的数据后，非常容易对系统重新训练。但同时端对端的训练对模型里面的每一步都要求能够后向传输梯度。通过知识库来自动回答问题，实际上是一个多步决策过程，里面的每一步决策是离散的，包含的知识实体的搜索和候选结果排序，这里面通过反向梯度比较困难。更好的做法是通过强化学习（reinforcement learning）,就是今年大红的AlphaGo的类似算法。如何更高效的做到搜索与排序统一的端对端的训练，这是一个非常值得研究的问题。机器之心：接下来，这项研究成果会应用在今日头条的那些产品和功能中？李磊：今日头条有个产品叫「头条问答」，类似于 Quora 。我们希望对于一些简单的问题和事实类的问题可以通过自动回答的方式去解决，这样就可以节省专家人力。头条问答中还有大量复杂的问题以及观点性的问题，目前我们的方法还不能解决这些问题，但我相信这方面的研究是会在这类产品上有应用的。机器之心：根据你的了解，其他问答类产品有用到类似的方法吗？李磊：Quora 等比较难的社区类问答还没有用到，但像 Stackoverflow 这种就用到了机器学习，它不一定是直接回答，而是说可以去做推荐。比如，这个问题推荐给谁来回答，那就需要对问题进行语义理解，以及回答了之后怎么来评判这个答案正确与否，质量有多高。所以 Stackoverflow 上的问题就更适合用机器学习来做。因为这些问题通常比较具体，且答案唯一。二、关于概率程序语言（PPL）机器之心：能否解释一下概率程序语言的概念，它和贝叶斯网络、马尔科夫网络之间的关系？以及概率程序语言的研究进展？李磊：概率程序语言是 2013 年兴起的提法，这条线的研究非常多，从最早的贝叶斯网络开始，对于含有逻辑和不确定两部分内容的事件如何表示，这个问题从八十年代末到现在一直都有研究。1）八十年代出现的是 Judea Pearl 提出的贝叶斯网络，他在 2011 年拿到了图灵奖。九十年代中期研究比较多的是逻辑编程，那时主要是基于逻辑规则的，当时有个很著名的编程语言叫 Prolog ，后来有人对它做了扩展，加上了概率，叫做概率逻辑程序（Probabilistic Logic Programming），把表达能力提升到可以去描述不确定事件。2）2000 年到 2005 年前后，又有很多人把一阶逻辑和概率结合起来，因为一阶逻辑比传统的逻辑变成的表达能力还要强一些，这体现出追求表达能力的研究主线，最早的贝叶斯网络实际上是命题逻辑和概率结合，而一阶逻辑的表达能力比命题逻辑要强，后面要做的是把一阶逻辑和概率结合起来，这个叫做概率一阶逻辑。3）这个发展到 2006 年，我当时的博士后导师 Stuart Russell（作者注：人工智能专家，经典教材《人工智能：一种现代方法》作者） 带领他的博士Brian Milch发明了贝叶斯逻辑 BLOG ，这不光包含了一阶逻辑和不确定，还融入了指代不确定性，比如「我知道这个屋子里有几个人，但我不知道他们是谁」。当时把一阶逻辑、概率和指代不确定三个东西都加起来，把概率程序语言方面的表达能力又提升了，从而发明了一种新的概率程序语言。4）同期还有些其他语言，比如华盛顿大学在 2006 年提出的马尔科夫逻辑网络，也是把一阶逻辑和概率结合起来，但概率是用通过马尔科夫无向图来表示的；Joshua Tenenbaum和他的学生Vikash Mansinghka 和Noah Goodman在 2008 年发明的 Church，但表示方式是不一样的，这个语言也是非常通用的。5）2012 年底 2013 年初，DARPA 把一些机器学习、程序语言和计算机系统的专家集中起来去探讨如何扩展机器学习技术，让更多的人去使用机器学习，我当时代表加州大学伯克利分校去参加。当时会议上提出来的一个新的概念就是概率编程（Probabilistic Programming），包含了之前的很多特例。概率编程的核心思路是给机器学习或者人工智能提供一个编程语言，它可以很容易的描述一些模型，同时自动为这个语言上的模型做概率推理和逻辑推理。一些应用方，比如社会学家、心理学家、经济学家和数据科学家，他们不需要特别深入的了解机器学习，只需要了解他们所在领域的问题，然后建立一个模型来描述人的认知，他就可以很容易的用这个语言去写一些模型出来，而且可以自动推理。建模的人不需要写非常多的程序去做计算和推理，因为通常这些部分都是比较难且耗时间的。这是当时提出的一个目标。6）2013 年 DARPA 还发布了一个很大的研究计划（作者注：即 PPAML 项目，用于先进机器学习的程序编程） ，现在美国在概率程序和程序推理系统方面的研究是非常前沿的。当然，目前这个领域的研究还处在初级阶段，因为大家很有野心，一方面要把概率程序语言做的非常通用，能够去描述各种模型，不管是概率的，还是非概率的；同时又希望最后做出来的自动推理算法运算速度非常快，既要有表示性又要有高效性，这两个目标同时达到是非常困难的。机器之心：之后，你还为 Blog 语言做了优化概率推理的 Swift 。李磊：在这个之前，大家做概率程序推理采用的方法都是通过解释型的，而我们是写了一个编译器对概率推理做优化，使得我能够为用户写出来的每一个模型专门做推理方面的优化，就像我写了一个 C++ 程序，用编译器可以对这个程序做优化，使它的计算速度可以非常快。如果类比一样，用 C++ 写的程序要比用 Python 写的快几十倍，同样，我们写的编译器也会比传统的概率推理快几十到上百倍。三、关于知识表示、问答和自然语言处理机器之心：知识表示是人工智能领域里的研究难题，你能否介绍一下这方面的研究进展？李磊：知识表示是人工智能最核心的问题，一般有五个框架。第一个是深度学习，它是用神经网络去逼近任何一个函数，这种表示方法在有监督学习里是非常有效的，尤其是在现在数据量非常大的情况下。第二类是基于概率图模型，比如贝叶斯网络和马尔科夫网络，这是去表达变量之间依赖关系的，不确定性。现在对这类框架又有了一些扩展，比如概率程序语言，可以表达既有概率同时又有逻辑的关系，将概率和逻辑结合起来去描述这个事件的不确定性。第三类是矩阵分解和稀疏方法，这种框架认为，表达每个物体需要多个特征，但并不是每个物体的所有特征上都有观测值，真实的表示可能是比较稀疏的，用稀疏模型去描述这个世界和物体之间的关系，这个在推荐里用的非常多。第四类是核方法（Kernel Method），它的核心是去描述两个物体之间的相似度，可以是用线性的方法和非线性的方法。最后一类是基于决策树，以及树的组合。这五类是从八十年代至今用的比较多的知识表示的框架，各有优劣。具体到我们的这篇论文，我们在解决这个问题（知识类问答）是用的第一类深度学习的方法，我们在解决其他问题时也有用到概率图模型的。机器之心：问答的发展离不开知识图谱，而目前知识图谱的构建又比较困难，你认为特定领域内的知识图谱有什么比较好的快速构建方法吗？李磊：我不是知识图谱方面的专家，专门做这方面的主要是研究信息提取，知识图谱还是比较困难的。那对于问答来说，并不一定依赖于知识图谱，后者只是其中的一个方法。但知识图谱确实非常有用的，在构建方面最近出现了一些新思路，比如华盛顿大学Oren Etzioni 提出了Open information extraction，CMU  Tom Michell 提出了 Never Ending Learning ，不断去读网上的文本数据，希望从中抓出实体和实体之间的关系，然后每天不断的读，不断的积累 confidence ，这样对实体的信息获取就越来越多，每天都在进步，就像人在获取知识一样。机器之心：问答和自然语言处理也有着密不可分的关系，你如何看待这方面的研究？李磊：我把自然语言处理问题分成简单任务和困难任务，简单的又分成两种，一是对句法结构进行分析，比如中文需要分词；另一种是浅层语义理解，比如说「从北京到上海乘火车怎么走？」，你把起点「北京」、终点「上海」找出来，把方式「乘火车」找出来，那整个句子的语义就理解了。这是浅层理解。困难的任务包括机器翻译、阅读理解、对话、问答（问答是对话的一类），我认为可以把自然语言处理问题都归约成对话问题。©本文由机器之心原创，转载请联系本公众号获得授权。

类的加载过程JVM中的类加载过程分为三步:装载: Load链接: Link初始化: Initialize装载查找并加载类的二进制数据链接验证: 确保加载类的正确性准备: 为类的静态变量分配内存,将将这些静态变量初始化为默认值解析: 将类中的符号引用转换为直接引用之所以要有验证的步骤:首先如果由编译器生成的class文件,必定符合JVM字节码格式但是,如果使用自定义的class文件,在JVM中加载运行,会导致安全问题因此需要为class文件添加验证的步骤,如果不符合,就不会继续执行,保证JVM安全初始化为类的静态变量赋予正确的初始值准备阶段和初始化阶段似乎有矛盾,但其实并不矛盾:假如类中有这样的语句: private static int a = 10 , 该语句的执行过程如下:首先字节码文件加载到内存中进行链接的验证步骤验证通过后进行准备步骤,给a分配内存因为变量a是static属性,所以a的值为int类型的默认初始值0,即a = 0然后进行到解析的步骤只有到初始化步骤时,才把a的真正的值10赋给a,此时a = 10类的初始化类进行初始化的场景创建类的实例,即new一个新的对象时访问某个类或者接口的静态变量,或者对这样的静态变量赋值时调用类的静态方法时反射: Class.forName("XxxClass")初始化一个类的子类时,会首先初始化子类的父类JVM启动时标明的启动类时,即文件名和类名相同的类类的初始化步骤如果这个类还没有被加载和链接,就首先进行装载和链接如果这个类存在直接父类,并且这个类还没有被初始化(在一个类加载器中,类只能初始化一次),就初始化直接的父类. 这个情况不适用于接口加入类中存在初始化语句,比如static变量或者static块, 就执行这些初始化语句类的加载类的加载过程将类的 .class文件中的二进制数据 读入到内存中将这些数据放在运行时的数据区的方法区内在堆区创建一个这个类的java.lang.Class对象,用来封装类在方法区类的对象类的加载最终生成位于堆区中的Class对象Class对象封装了类在方法区内的数据结构Class对象提供了访问方法区内的数据结构的接口类的加载方式从本地系统直接加载通过网络下载.class文件从zip, jar等归档文件中加载.class文件从专有数据库中提取.class文件将Java源文件动态编译为.class文件,比如服务器类加载器Java的类加载是通过ClassLoader及其子类来完成的Bootstrap ClassLoader负责加载 $JAVA_HOME中jre/lib/rt.jar里所有的class, 由C++ 实现,不是ClassLoader类Extension ClassLoader负责加载Java平台中扩展功能的一些jar包,包括 $JAVA_HOME中jre/lib/*.jar或者 -Djava.ext.dirs指定目录下的jar包App ClassLoader负责加载classpath中指定的jar包及目录中classCustom ClassLoader应用程序根据自身需要自定义的ClassLoaderTomcat,JBoss都会根据J2EE规范自行实现ClassLoader加载过程类加载器首先会检查类是否已经被加载检查顺序自底向上,从Custom ClassLoader到BootStrap ClassLoader逐层检查只要某个ClassLoader已加载就表示已加载此类,保证此类的所有ClassLoader至少要被加载一次加载的顺序是自顶向下,由上层来逐层尝试加载此类

? 通配符类型? extends T表示类型的上界:表示参数化类型的可以是T或者T的子类? super T表示类型的下界:表示参数化类型是这个类型的超类型,即父类型,直至Object? extends T上界? extends T只能往外取,不能往里存通配符 ? 和类型参数 T 的区别:对于编译器来说,所有的T都代表同一种类型通配符?没有这样的约束,只表示放置了一个类型,具体是什么类型不能确定? extends T的作用:在List中不能使用add方法可以在初始化时,指定不同的类型这样就能读取出不同类型的数据? super T? super T可以往里存数据,往外取数据只能放在Object对象中? super T只能添加T类型和T类型的子类,不能添加T类型的父类,读取出来的东西只能存放在Object类里下界规定了元素的最小粒度的下限,放宽了容器元素的类型控制因为元素是T的基类,所以往里存比T 小的都可以出于类型安全的考虑,可以往里加入T类的对象或者T类的任何子类的对象由于编译器并不知道集合的内容源自T的哪一个超类,所以不允许加入特定的任何超类对象在读取时,编译器不知道是什么类型的情况下,只能返回Object对象因为Object是任何Java类的最终父类这时,元素的类型信息全部丢失PECS原则PECS原则: Producer Extends Consumer Super频繁往外读取内容的,适合使用上界Extends经常往里插入内容的,适合使用下界Super总结extends可以用于返回类型限定super可以用于参数类型限定,不能用于返回类型限定? 既不能用于方法参数传入,也不能用于方法返回带有extends子类型限定的通配符可以向泛型对象进行读取带有super超类型限定的通配符可以向泛型对象中进行写入