JavaCC 是 java 生态中常用的Parser Generator。特征如下:

• JavaCC 生成的解析器是基于LL 的，默认是LL(1)，通过配置可以支持 LL(K)。
• 由于是LL 方式，需要用户自己书写递归下降的语法规则来避免出现左递归问题。
• JavaCC 支持 EBNF 语法范式。

JavaCC的工作流程如下:

• 令牌管理器读入一个字符序列并生成一个称为令牌的对象序列。用于将字符序列分解为标记序列的规则取决于语言-它们由用户作为正则表达式的集合提供。
• 解析器使用一个令牌序列，分析它的结构，并产生一个由用户定义的输出。

假设我有两个 github 账号，victor(for personal) 和 superman(for work)。如果我想在同一台电脑上使用这两个账号进行 git push/pull。该如何配置？

如何在 Rust 的多线程中共享值？

• 共享值的方式是使用Arc
• 修改值的方式是使用Mutex

Rust 既支持了基于系统线程的多线程编程模型，也支持了基于async/await的异步编程模型。Rust 的async编程有有以下特性:

• Future 在 Rust 中是惰性的
• Async 在 Rust 中使用开销是零
• Rust 没有内置异步调用所必需的运行时，但是社区生态中已经提供了非常优异的运行时实现，例如 tokio和async-std
• 运行时同时支持单线程和多线程

Tower是一个模块化和可重用组件库，用于构建健壮的网络客户端和服务器。其核心是Service特征。Service是一个异步函数，它接受请求并产生响应。然而，其设计的某些方面可能并不明显。与其解释目前Tower中存在的Service特征，让我们通过想象如果你从头开始，你会如何发明它来看看Service背后的动机。

本文将介绍如果基于 vscode 搭建 Rust 开发环境。

先来看一段 Java 代码，Application中有version和 logger。logger 依赖了 Version。

public class Application
{
    public Version version;
    public Logger logger;
    public Application() {
        version = new Version(1);
        logger =  new Logger(version);
    }

    public static void main(String[] args)
    {
        Application application = new Application();
        application.logger.log("Hello World!");
        // console output:
        // [version 1] Hello World!
    }
    class Version {
        public int ver;
        public Version (int ver){
            this.ver = ver;
        }
        public String toString() {
            return String.format("version %d",ver);
        }
    }
    class Logger {
        public Version version;
        public Logger (Version version){
            this.version = version;
        }
        void log(String msg) {
            System.out.println(String.format("[%s] %s",version,msg));
        }
    }
}

那么问题来了，如何在 Rust 中实现相同的代码？

生命周期，简而言之就是引用的有效作用域。在大多数时候，我们无需手动的声明生命周期，因为编译器可以自动进行推导。当多个生命周期存在，且编译器无法推导出某个引用的生命周期时，就需要我们手动标明生命周期。

悬垂指针和生命周期

生命周期的主要作用是避免悬垂引用，它会导致程序引用了本不该引用的数据：

{
    let r;
    {
        let x = 5;
        r = &x;
    }    // ^^ borrowed value does not live long enough
    println!("r: {}", r);
}

此处 r 就是一个悬垂指针，它引用了提前被释放的变量 x。

借用检查

为了保证 Rust 的所有权和借用的正确性，Rust 使用了一个借用检查器(Borrow checker)，来检查我们程序的借用正确性：

{
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {}", r); //          |
}                         // ---------+

r 变量被赋予了生命周期 ‘a，x 被赋予了生命周期 ‘b，从图示上可以明显看出生命周期 ‘b 比 ‘a 小很多。在编译期，Rust 会比较两个变量的生命周期，结果发现 r 明明拥有生命周期 ‘a，但是却引用了一个小得多的生命周期 ‘b，在这种情况下，编译器会认为我们的程序存在风险，因此拒绝运行。如果想要编译通过，也很简单，只要 ‘b 比 ‘a 大就好。总之，x 变量只要比 r 活得久，那么 r 就能随意引用 x 且不会存在危险：

{
    let x = 5;            // ----------+-- 'b
                          //           |
    let r = &x;           // --+-- 'a  |
                          //   |       |
    println!("r: {}", r); //   |       |
                          // --+       |
}                         // ----------+

TCP协议是一种面向连接的有状态网络协议。对于发送的每个数据包，一旦TCP堆栈收到特定数据包的ACK，它就认为它已成功传递。

TCP使用指数退避超时重传一个未确认的数据包，最多tcp_retries2时间（默认为15），每次重传超时在TCP_RTO_MIN（200毫秒）和TCP_RTO_MAX（120秒）之间。一旦第15次重试到期（默认情况下），TCP堆栈将通知上面的层（即应用程序）断开连接。

上篇博客介绍了 CPU异常分析的工具和方法。本文将介绍如何定位 CPU 耗时。